private void writeResourceMethod()

in tools/wadlto/jaxrs/src/main/java/org/apache/cxf/tools/wadlto/jaxrs/SourceGenerator.java [633:800]
146 lines of code
35 McCabe index (conditional complexity)

    private void writeResourceMethod(Element methodEl,
                                     String classPackage,
                                     Set<String> imports,
                                     StringBuilder sbCode,
                                     ContextInfo info,
                                     boolean isRoot,
                                     String currentPath,
                                     Map<String, Integer> methodNameMap) {
    //CHECKSTYLE:ON: ParameterNumber
        StringBuilder sbMethodCode = sbCode;
        StringBuilder sbMethodDocs = null;
        StringBuilder sbMethodRespDocs = null;

        boolean doCreateJavaDocs = isJavaDocNeeded(info);
        if (doCreateJavaDocs) {
            sbMethodCode = new StringBuilder();
            sbMethodDocs = startMethodDocs(methodEl);
            sbMethodRespDocs = new StringBuilder();
        }

        boolean isResourceElement = "resource".equals(methodEl.getLocalName());
        Element resourceEl = isResourceElement ? methodEl : (Element)methodEl.getParentNode();

        List<Element> responseEls = getWadlElements(methodEl, "response");
        List<Element> requestEls = getWadlElements(methodEl, "request");
        Element firstRequestEl = !requestEls.isEmpty() ? requestEls.get(0) : null;
        List<Element> allRequestReps = getWadlElements(firstRequestEl, "representation");
        List<Element> requestRepsWithElements = new ArrayList<>();
        boolean duplicatesAvailable =
            getRepsWithElements(allRequestReps, requestRepsWithElements, info.getGrammarInfo());

        String methodName = methodEl.getAttribute("name");
        final String methodNameLowerCase = methodName.toLowerCase();
        String idAttribute = methodEl.getAttribute("id");
        final String id = idAttribute.isEmpty() ? methodNameLowerCase : idAttribute;

        final boolean responseRequired = isMethodMatched(responseMethods, methodNameLowerCase, id);
        final boolean suspendedAsync = !responseRequired
            && isMethodMatched(suspendedAsyncMethods, methodNameLowerCase, id);
        final boolean oneway = isMethodMatched(onewayMethods, methodNameLowerCase, id);

        boolean jaxpSourceRequired = requestRepsWithElements.size() > 1 && !supportMultipleRepsWithElements;
        int numOfMethods = jaxpSourceRequired ? 1 : requestRepsWithElements.size();

        for (int i = 0; i < numOfMethods; i++) {

            List<Element> requestReps = allRequestReps;

            Element requestRepWithElement = requestRepsWithElements.get(i);
            String suffixName = "";
            if (supportMultipleRepsWithElements && requestRepWithElement != null
                && requestRepsWithElements.size() > 1) {
                String elementRef = requestRepWithElement.getAttribute("element");
                int index = elementRef.indexOf(':');
                suffixName = elementRef.substring(index + 1).replace("-", "");
                if (duplicatesAvailable) {
                    String mediaType = requestRepWithElement.getAttribute("mediaType");
                    if (!StringUtils.isEmpty(mediaType)) {
                        String subType = MediaType.valueOf(mediaType).getSubtype();
                        String[] parts = subType.split("\\+");
                        if (parts.length == 2) {
                            suffixName += StringUtils.capitalize(parts[1]);
                        } else {
                            suffixName += StringUtils.capitalize(parts[0].replaceAll("[\\.-]", ""));
                        }
                    }
                }
                requestReps = Collections.singletonList(requestRepWithElement);
            }
            if (writeAnnotations(info.isInterfaceGenerated())) {
                sbMethodCode.append(TAB);

                if (!methodNameLowerCase.isEmpty()) {
                    if (HTTP_METHOD_ANNOTATIONS.containsKey(methodNameLowerCase)) {
                        writeAnnotation(sbMethodCode, imports, HTTP_METHOD_ANNOTATIONS.get(methodNameLowerCase), null)
                            .append(lineSeparator).append(TAB);
                    } else {
                        writeCustomHttpMethod(info, classPackage, methodName, sbMethodCode, imports);
                    }
                    writeFormatAnnotations(requestReps, sbMethodCode, imports, true, null);
                    List<Element> responseReps = getWadlElements(getOKResponse(responseEls), "representation");
                    writeFormatAnnotations(responseReps,
                                           sbMethodCode, imports, false, requestRepWithElement);
                    if (supportBeanValidation && !responseRequired
                        && isRepWithElementAvailable(responseReps, info.getGrammarInfo())) {
                        addImport(imports, BEAN_VALID_FULL_NAME);
                        sbMethodCode.append('@').append(BEAN_VALID_SIMPLE_NAME).append(lineSeparator).append(TAB);
                    }
                    if (oneway) {
                        writeAnnotation(sbMethodCode, imports, Oneway.class, null)
                            .append(lineSeparator).append(TAB);
                    }
                }
                if (!isRoot && !"/".equals(currentPath)) {
                    writeAnnotation(sbMethodCode, imports, Path.class, currentPath)
                        .append(lineSeparator).append(TAB);
                }
            } else {
                sbMethodCode.append(lineSeparator).append(TAB);
            }

            if (!info.isInterfaceGenerated()) {
                sbMethodCode.append("public ");
            }
            boolean responseTypeAvailable = true;

            if (!methodNameLowerCase.isEmpty()) {
                responseTypeAvailable = writeResponseType(responseEls,
                                                          requestRepWithElement,
                                                          sbMethodCode,
                                                          sbMethodRespDocs,
                                                          imports,
                                                          info,
                                                          responseRequired,
                                                          suspendedAsync);

                String genMethodName = id + suffixName;
                if (methodNameLowerCase.equals(genMethodName) && idAttribute.isEmpty()) {
                    List<PathSegment> segments = JAXRSUtils.getPathSegments(currentPath, true, true);
                    StringBuilder sb = new StringBuilder();
                    for (PathSegment ps : segments) {
                        String pathSeg = ps.getPath().replaceAll("\\{", "").replaceAll("\\}", "");
                        int index = pathSeg.indexOf(':');
                        if (index > 0) {
                            pathSeg = pathSeg.substring(0, index);
                        }
                        sb.append(pathSeg);
                    }
                    genMethodName += StringUtils.capitalize(sb.toString());
                }
                genMethodName = genMethodName.replace("-", "");

                Integer value = methodNameMap.get(genMethodName);
                if (value == null) {
                    value = 0;
                }
                methodNameMap.put(genMethodName, ++value);
                if (value > 1) {
                    genMethodName = genMethodName + value.toString();
                }

                sbMethodCode.append(genMethodName);
            } else {
                writeSubresourceMethod(resourceEl, imports, sbMethodCode, info, id, suffixName);
            }

            sbMethodCode.append('(');

            List<Element> inParamElements = getParameters(resourceEl, info.getInheritedParams(),
                        !isRoot && !isResourceElement && !resourceEl.getAttribute("id").isEmpty());

            Element repElement = getActualRepElement(allRequestReps, requestRepWithElement);
            writeRequestTypes(firstRequestEl, classPackage, repElement, inParamElements,
                    jaxpSourceRequired, sbMethodCode, sbMethodDocs, imports, info, suspendedAsync);
            sbMethodCode.append(')');

            writeThrows(responseEls, sbMethodCode, sbMethodDocs, imports, info);

            if (info.isInterfaceGenerated()) {
                sbMethodCode.append(';');
            } else {
                generateEmptyMethodBody(sbMethodCode, responseTypeAvailable);
            }
            sbMethodCode.append(lineSeparator).append(lineSeparator);
        }
        finalizeMethodDocs(doCreateJavaDocs, sbCode, sbMethodDocs, sbMethodRespDocs, sbMethodCode);

    }