public void writeExecutableParameters(CtExecutable<?> executable) { printList(executable.getParameters(), null, false, "(", false, false, ",", true, false, ")", p -> prettyPrinter.scan(p)); }
@Override public <T> void visitCtIntersectionTypeReference(CtIntersectionTypeReference<T> reference) { elementPrinterHelper.printList(reference.getBounds(), null, false, null, false, true, "&", true, false, null, bound -> scan(bound)); }
/** * Writes formal type parameters given in parameter. * * @param ctFormalTypeDeclarer * Reference with formal type arguments. */ public void writeFormalTypeParameters(CtFormalTypeDeclarer ctFormalTypeDeclarer) { final Collection<CtTypeParameter> parameters = ctFormalTypeDeclarer.getFormalCtTypeParameters(); if (parameters == null) { return; } if (!parameters.isEmpty()) { printList(parameters, null, false, "<", false, false, ",", true, false, ">", parameter -> prettyPrinter.scan(parameter)); } }
/** writes the thrown exception with a ListPrinter */ public void writeThrowsClause(CtExecutable<?> executable) { if (!executable.getThrownTypes().isEmpty()) { printList(executable.getThrownTypes(), "throws", false, null, false, false, ",", true, false, null, ref -> prettyPrinter.scan(ref)); } }
/** writes the implemented interfaces with a ListPrinter */ public void writeImplementsClause(CtType<?> type) { if (!type.getSuperInterfaces().isEmpty()) { printList(type.getSuperInterfaces(), "implements", false, null, false, true, ",", true, false, null, ref -> prettyPrinter.scan(ref)); } }
/** * Writes actual type arguments in a {@link CtActualTypeContainer} element. * * @param ctGenericElementReference * Reference with actual type arguments. */ public void writeActualTypeArguments(CtActualTypeContainer ctGenericElementReference) { final Collection<CtTypeReference<?>> arguments = ctGenericElementReference.getActualTypeArguments(); if (arguments != null && !arguments.isEmpty()) { printList(arguments.stream().filter(a -> !a.isImplicit())::iterator, null, false, "<", false, false, ",", true, false, ">", argument -> { if (prettyPrinter.getContext().forceWildcardGenerics()) { printer.writeSeparator("?"); } else { prettyPrinter.scan(argument); } }); } }
@Override public <A extends Annotation> void visitCtAnnotation(CtAnnotation<A> annotation) { elementPrinterHelper.writeAnnotations(annotation); printer.writeSeparator("@"); scan(annotation.getAnnotationType()); if (!annotation.getValues().isEmpty()) { elementPrinterHelper.printList(annotation.getValues().entrySet(), null, false, "(", false, false, ",", true, false, ")", e -> { if ((annotation.getValues().size() == 1 && "value".equals(e.getKey())) == false) { //it is not a default value attribute. We must print a attribute name too. printer.writeIdentifier(e.getKey()).writeSpace().writeOperator("=").writeSpace(); } elementPrinterHelper.writeAnnotationElement(annotation.getFactory(), e.getValue()); }); } }
@Override public void visitCtModuleRequirement(CtModuleRequirement moduleRequirement) { printer.writeKeyword("requires").writeSpace(); if (!moduleRequirement.getRequiresModifiers().isEmpty()) { this.elementPrinterHelper.printList(moduleRequirement.getRequiresModifiers(), null, false, null, false, false, " ", false, false, " ", modifier -> printer.writeKeyword(modifier.name().toLowerCase())); } scan(moduleRequirement.getModuleReference()); printer.writeSeparator(";").writeln(); }
@Override public void visitCtProvidedService(CtProvidedService moduleProvidedService) { printer.writeKeyword("provides").writeSpace(); scan(moduleProvidedService.getServiceType()); this.elementPrinterHelper.printList(moduleProvidedService.getImplementationTypes(), null, false, " with", true, false, ",", true, false, null, implementations -> scan(implementations)); printer.writeSeparator(";").writeln(); }
@Override public void visitCtPackageExport(CtPackageExport moduleExport) { if (moduleExport.isOpenedPackage()) { printer.writeKeyword("opens"); } else { printer.writeKeyword("exports"); } printer.writeSpace(); visitCtPackageReference(moduleExport.getPackageReference()); if (!moduleExport.getTargetExport().isEmpty()) { this.elementPrinterHelper.printList(moduleExport.getTargetExport(), null, false, " to", true, false, ",", true, false, null, moduleReference -> scan(moduleReference)); } printer.writeSeparator(";").writeln(); }
printer.writeLiteral("\"" + LiteralHelper.getStringLiteral((String) value, true) + "\""); } else if (value instanceof Collection) { printList((Collection<?>) value, null, false, "{", false, true, ",", false, false, "}", obj -> writeAnnotationElement(factory, obj)); } else if (value instanceof Object[]) { printList(Arrays.asList((Object[]) value), null, false, "{", false, true, ",", false, false, "}", obj -> writeAnnotationElement(factory, obj));
printer.writeSpace(); elementPrinterHelper.printList(forLoop.getForUpdate(), null, false, null, false, true, ",", true, false, null, s -> scan(s));
@Override public <T> void visitCtEnumValue(CtEnumValue<T> enumValue) { elementPrinterHelper.visitCtNamedElement(enumValue, sourceCompilationUnit); elementPrinterHelper.writeComment(enumValue, CommentOffset.BEFORE); printer.writeIdentifier(enumValue.getSimpleName()); if (enumValue.getDefaultExpression() != null) { CtConstructorCall<?> constructorCall = (CtConstructorCall<?>) enumValue.getDefaultExpression(); if (!constructorCall.isImplicit()) { elementPrinterHelper.printList(constructorCall.getArguments(), null, false, "(", false, false, ",", true, false, ")", expr -> scan(expr)); } if (constructorCall instanceof CtNewClass) { scan(((CtNewClass<?>) constructorCall).getAnonymousClass()); } } }
@Override public void visitCtCatch(CtCatch catchBlock) { elementPrinterHelper.writeComment(catchBlock, CommentOffset.BEFORE); printer.writeSpace().writeKeyword("catch").writeSpace().writeSeparator("("); CtCatchVariable<? extends Throwable> parameter = catchBlock.getParameter(); if (parameter != null && parameter.getMultiTypes().size() > 1) { elementPrinterHelper.printList(parameter.getMultiTypes(), null, false, null, false, true, "|", true, false, null, type -> scan(type)); printer.writeSpace().writeIdentifier(parameter.getSimpleName()); } else { scan(parameter); } printer.writeSeparator(")").writeSpace(); scan(catchBlock.getBody()); }
@Override public <T> void visitCtLambda(CtLambda<T> lambda) { enterCtExpression(lambda); elementPrinterHelper.printList(lambda.getParameters(), null, false, "(", false, false, ",", false, false, ")", parameter -> scan(parameter)); printer.writeSpace(); printer.writeSeparator("->"); printer.writeSpace(); if (lambda.getBody() != null) { scan(lambda.getBody()); } else { scan(lambda.getExpression()); } exitCtExpression(lambda); }
elementPrinterHelper.printList(newArray.getElements(), null, false, "{", true, false, ",", true, true, "}", e -> scan(e));
private <T> void printConstructorCall(CtConstructorCall<T> ctConstructorCall) { try (Writable _context = context.modify()) { if (ctConstructorCall.getTarget() != null) { scan(ctConstructorCall.getTarget()); printer.writeSeparator("."); _context.ignoreEnclosingClass(true); } if (hasDeclaringTypeWithGenerics(ctConstructorCall.getType())) { _context.ignoreEnclosingClass(true); } printer.writeKeyword("new").writeSpace(); if (!ctConstructorCall.getActualTypeArguments().isEmpty()) { elementPrinterHelper.writeActualTypeArguments(ctConstructorCall); } scan(ctConstructorCall.getType()); } elementPrinterHelper.printList(ctConstructorCall.getArguments(), null, false, "(", false, false, ",", true, false, ")", exp -> scan(exp)); }
@Override public <T> void visitCtInterface(CtInterface<T> intrface) { visitCtType(intrface); printer.writeKeyword("interface").writeSpace().writeIdentifier(intrface.getSimpleName()); if (intrface.getFormalCtTypeParameters() != null) { elementPrinterHelper.writeFormalTypeParameters(intrface); } if (!intrface.getSuperInterfaces().isEmpty()) { elementPrinterHelper.printList(intrface.getSuperInterfaces(), "extends", false, null, false, true, ",", true, false, null, ref -> scan(ref)); } context.pushCurrentThis(intrface); printer.writeSpace().writeSeparator("{").incTab(); // Content elementPrinterHelper.writeElementList(intrface.getTypeMembers()); printer.decTab().writeSeparator("}"); context.popCurrentThis(); }
@Override public void visitCtTryWithResource(CtTryWithResource tryWithResource) { enterCtStatement(tryWithResource); printer.writeKeyword("try").writeSpace(); if (tryWithResource.getResources() != null && !tryWithResource.getResources().isEmpty()) { elementPrinterHelper.printList(tryWithResource.getResources(), null, false, "(", false, false, ";", false, false, ")", r -> scan(r)); } printer.writeSpace(); scan(tryWithResource.getBody()); for (CtCatch c : tryWithResource.getCatchers()) { scan(c); } if (tryWithResource.getFinalizer() != null) { printer.writeSpace().writeKeyword("finally").writeSpace(); scan(tryWithResource.getFinalizer()); } exitCtStatement(tryWithResource); }
@Override public <T extends Enum<?>> void visitCtEnum(CtEnum<T> ctEnum) { visitCtType(ctEnum); printer.writeKeyword("enum").writeSpace().writeIdentifier(ctEnum.getSimpleName()); elementPrinterHelper.writeImplementsClause(ctEnum); context.pushCurrentThis(ctEnum); printer.writeSpace().writeSeparator("{").incTab().writeln(); if (ctEnum.getEnumValues().isEmpty()) { printer.writeSeparator(";").writeln(); } else { elementPrinterHelper.printList(ctEnum.getEnumValues(), null, false, null, false, false, ",", false, false, ";", enumValue -> { printer.writeln(); scan(enumValue); }); } elementPrinterHelper.writeElementList(ctEnum.getTypeMembers()); printer.decTab().writeSeparator("}"); context.popCurrentThis(); }