docs: private void parseControllerMethod(JaxrsApplicationParser.Result result, JaxrsApplicationParser.ResourceContext context, Class<?> controllerClass, Method method) {
          final RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(method, RequestMapping.class);
          if (requestMapping != null) {
  
              // subContext
              context = context.subPath(requestMapping.path().length == 0 ? "" : requestMapping.path()[0]);
              final Map<String, Type> pathParamTypes = new LinkedHashMap<>();
              for (Parameter parameter : method.getParameters()) {
                  final PathVariable pathVariableAnnotation = parameter.getAnnotation(PathVariable.class);
                  if (pathVariableAnnotation != null) {
                      pathParamTypes.put(pathVariableAnnotation.value(), parameter.getParameterizedType());
                  }
              }
              context = context.subPathParamTypes(pathParamTypes);
              final RequestMethod httpMethod = requestMapping.method().length == 0 ? RequestMethod.GET : requestMapping.method()[0];
  
              // path parameters
              final PathTemplate pathTemplate = PathTemplate.parse(context.path);
              final Map<String, Type> contextPathParamTypes = context.pathParamTypes;
              final List<MethodParameterModel> pathParams = pathTemplate.getParts().stream()
                      .filter(PathTemplate.Parameter.class::isInstance)
                      .map(PathTemplate.Parameter.class::cast)
                      .map(parameter -> {
                          final Type type = contextPathParamTypes.get(parameter.getOriginalName());
                          final Type paramType = type != null ? type : String.class;
                          foundType(result, paramType, controllerClass, method.getName());
                          return new MethodParameterModel(parameter.getValidName(), paramType);
                      })
                      .collect(Collectors.toList());
  
              // query parameters
              final List<RestQueryParam> queryParams = new ArrayList<>();
              for (Parameter param : method.getParameters()) {
                  final RequestParam requestParamAnnotation = param.getAnnotation(RequestParam.class);
                  if (requestParamAnnotation != null) {
                      queryParams.add(new RestQueryParam.Single(new MethodParameterModel(requestParamAnnotation.value(), param.getParameterizedType())));
                      foundType(result, param.getParameterizedType(), controllerClass, method.getName());
                  }
              }
  
              // entity parameter
              final MethodParameterModel entityParameter = getEntityParameter(method);
              if (entityParameter != null) {
                  foundType(result, entityParameter.getType(), controllerClass, method.getName());
              }
  
              // return Type
              final Class<?> returnType = method.getReturnType();
              final Type genericReturnType = method.getGenericReturnType();
              final Type modelReturnType;
              if (genericReturnType instanceof ParameterizedType && returnType == ResponseEntity.class) {
                  final ParameterizedType parameterizedReturnType = (ParameterizedType) genericReturnType;
                  modelReturnType = parameterizedReturnType.getActualTypeArguments()[0];
                  foundType(result, modelReturnType, controllerClass, method.getName());
              } else {
                  modelReturnType = genericReturnType;
                  foundType(result, modelReturnType, controllerClass, method.getName());
              }
  
              model.getMethods().add(new RestMethodModel(controllerClass, method.getName(), modelReturnType,
                      controllerClass, httpMethod.name(), context.path, pathParams, queryParams, entityParameter, null));
          }
      }