/** * Gets all the annotations on the given declaration. */ private Annotation[] getAllAnnotations(Element decl, Locatable srcPos) { List<Annotation> r = new ArrayList<Annotation>(); for( AnnotationMirror m : decl.getAnnotationMirrors() ) { try { String fullName = ((TypeElement) m.getAnnotationType().asElement()).getQualifiedName().toString(); Class<? extends Annotation> type = SecureLoader.getClassClassLoader(getClass()).loadClass(fullName).asSubclass(Annotation.class); Annotation annotation = decl.getAnnotation(type); if(annotation!=null) r.add( LocatableAnnotation.create(annotation,srcPos) ); } catch (ClassNotFoundException e) { // just continue } } return r.toArray(new Annotation[r.size()]); }
public Content getTypeAnnotationLinks(LinkInfo linkInfo) { Utils utils = ((LinkInfoImpl)linkInfo).utils; Content links = newContent(); if (!utils.isAnnotated(linkInfo.type)) return links; List<? extends AnnotationMirror> annotations = linkInfo.type.getAnnotationMirrors(); boolean needSpace = false; for (AnnotationMirror anno : annotations) { if (needSpace) { links.addContent(" "); } links.addContent(getTypeAnnotationLink(linkInfo, anno)); needSpace = true; } links.addContent(" "); return links; }
@Override public Result checkElement(final ExecutableElement element) { if (!ValueHandlerAnnoRetriever.hasAnnotation(element)) { return Result.createSuccessful(); } final AnnotationMirror anno = ValueHandlerAnnoRetriever.getAnnotation(element); final MethodSpec supplier = getValueMethodGenerator.generateFor(anno); final TypeMirror suppliedType = returnTypeToTypeMirror(supplier); final TypeMirror recipientType = getParameterWithoutUseAnnotation(element).asType(); if (!isAssignableOrConvertible(suppliedType, recipientType)) { return Result.createFailure( "Misused handler annotation found. \'%1$s\' cannot be cast to \'%2$s\'.", suppliedType, recipientType); } return Result.createSuccessful(); }
public static List<JoinColumn> getJoinColumns(final AnnotationModelHelper helper, Map<String, ? extends AnnotationMirror> annByType) { final List<JoinColumn> result = new ArrayList<JoinColumn>(); AnnotationMirror joinColumnAnn = annByType.get("javax.persistence.JoinColumn"); // NOI18N if (joinColumnAnn != null) { result.add(new JoinColumnImpl(helper, joinColumnAnn)); } else { AnnotationMirror joinColumnsAnnotation = annByType.get("javax.persistence.JoinColumns"); // NOI18N if (joinColumnsAnnotation != null) { AnnotationParser jcParser = AnnotationParser.create(helper); jcParser.expectAnnotationArray("value", helper.resolveType("javax.persistence.JoinColumn"), new ArrayValueHandler() { // NOI18N public Object handleArray(List<AnnotationValue> arrayMembers) { for (AnnotationValue arrayMember : arrayMembers) { AnnotationMirror joinColumnAnnotation = (AnnotationMirror)arrayMember.getValue(); result.add(new JoinColumnImpl(helper, joinColumnAnnotation)); } return null; } }, null); jcParser.parse(joinColumnsAnnotation); } } return result; }
public void testScanAnnotationsOnFields() throws Exception { final AnnotationModelHelper helper = AnnotationModelHelper.create(createClasspathInfoForScanningAnnotations()); final Set<String> elements = new HashSet<String>(); helper.runJavaSourceTask(new Callable<Void>() { public Void call() throws InterruptedException { helper.getAnnotationScanner().findAnnotations( "javax.annotation.Resource", EnumSet.of(ElementKind.FIELD), new AnnotationHandler() { public void handleAnnotation(TypeElement typeElement, Element element, AnnotationMirror annotationMirror) { assertEquals("foo.MyClass", typeElement.getQualifiedName().toString()); elements.add(element.getSimpleName().toString()); } }); return null; } }); assertEquals(1, elements.size()); assertTrue(elements.contains("myDS")); }
public ManyToManyImpl(final AnnotationModelHelper helper, final Element element, AnnotationMirror manyToManyAnnotation, String name, Map<String, ? extends AnnotationMirror> annByType) { this.name = name; AnnotationParser parser = AnnotationParser.create(helper); parser.expectClass("targetEntity", new DefaultProvider() { // NOI18N public Object getDefaultValue() { return EntityMappingsUtilities.getCollectionArgumentTypeName(helper, element); } }); parser.expectEnumConstantArray("cascade", helper.resolveType("javax.persistence.CascadeType"), new ArrayValueHandler() { // NOI18N public Object handleArray(List<AnnotationValue> arrayMembers) { return new CascadeTypeImpl(arrayMembers); } }, parser.defaultValue(new CascadeTypeImpl())); parser.expectEnumConstant("fetch", helper.resolveType("javax.persistence.FetchType"), parser.defaultValue("LAZY")); // NOI18N parser.expectString("mappedBy", parser.defaultValue("")); // NOI18N parseResult = parser.parse(manyToManyAnnotation); joinTable = new JoinTableImpl(helper, annByType.get("javax.persistence.JoinTable")); // NOI18N }
private boolean isDaggerRequired( @Nonnull final TypeElement typeElement, @Nullable final AnnotationMirror scopeAnnotation ) { final VariableElement daggerParameter = (VariableElement) ProcessorUtil.getAnnotationValue( processingEnv.getElementUtils(), typeElement, Constants.COMPONENT_ANNOTATION_CLASSNAME, "dagger" ).getValue(); switch ( daggerParameter.getSimpleName().toString() ) { case "ENABLE": return true; case "DISABLE": return false; default: return null != scopeAnnotation && null != processingEnv.getElementUtils().getTypeElement( Constants.DAGGER_MODULE_CLASSNAME ); } }
public void testScanAnnotationsOnMethods() throws Exception { final AnnotationModelHelper helper = AnnotationModelHelper.create(createClasspathInfoForScanningAnnotations()); final Set<String> elements = new HashSet<String>(); helper.runJavaSourceTask(new Callable<Void>() { public Void call() throws InterruptedException { helper.getAnnotationScanner().findAnnotations( "javax.annotation.Resource", EnumSet.of(ElementKind.METHOD), new AnnotationHandler() { public void handleAnnotation(TypeElement typeElement, Element element, AnnotationMirror annotationMirror) { assertEquals("foo.YourClass", typeElement.getQualifiedName().toString()); elements.add(element.getSimpleName().toString()); } }); return null; } }); assertEquals(1, elements.size()); assertTrue(elements.contains("setYourDataSource")); }
@Override public MethodSpec supplyFor(final AnnotationMirror anno) { final CodeBlock body = CodeBlock .builder() .addStatement( "return $T.getColorStateList($N(), $L)", AndroidClassNames.CONTEXT_COMPAT, CallerDef.GET_CONTEXT, getLiteralFromAnnotation(anno, "resId")) .build(); return getBaseMethodSpec() .returns(AndroidClassNames.COLOR_STATE_LIST) .addCode(body) .build(); }
public OneToOneImpl(final AnnotationModelHelper helper, final Element element, AnnotationMirror oneToOneAnnotation, String name, Map<String, ? extends AnnotationMirror> annByType) { this.name = name; AnnotationParser parser = AnnotationParser.create(helper); parser.expectClass("targetEntity", new DefaultProvider() { // NOI18N public Object getDefaultValue() { return EntityMappingsUtilities.getElementTypeName(element); } }); parser.expectEnumConstantArray("cascade", helper.resolveType("javax.persistence.CascadeType"), new ArrayValueHandler() { // NOI18N public Object handleArray(List<AnnotationValue> arrayMembers) { return new CascadeTypeImpl(arrayMembers); } }, parser.defaultValue(new CascadeTypeImpl())); parser.expectEnumConstant("fetch", helper.resolveType("javax.persistence.FetchType"), parser.defaultValue("EAGER")); // NOI18N parser.expectPrimitive("optional", Boolean.class, parser.defaultValue(true)); // NOI18N parser.expectString("mappedBy", parser.defaultValue("")); // NOI18N parseResult = parser.parse(oneToOneAnnotation); joinTable = new JoinTableImpl(helper, annByType.get("javax.persistence.JoinTable")); // NOI18N joinColumnList = EntityMappingsUtilities.getJoinColumns(helper, annByType); pkJoinColumnList = EntityMappingsUtilities.getPrimaryKeyJoinColumns(helper, annByType); }
private static Boolean findAnnotationValueAsBoolean(Element fieldElement, String[] fieldAnnotationFqns, String annotationKey) { Boolean isFieldXable = null; for (int i = 0; i < fieldAnnotationFqns.length; i++) { String fieldAnnotationFqn = fieldAnnotationFqns[i]; AnnotationMirror fieldAnnotation = JpaControllerUtil.findAnnotation(fieldElement, fieldAnnotationFqn); //NOI18N if (fieldAnnotation != null) { String annotationValueString = JpaControllerUtil.findAnnotationValueAsString(fieldAnnotation, annotationKey); //NOI18N if (annotationValueString != null) { isFieldXable = Boolean.valueOf(annotationValueString); } else { isFieldXable = Boolean.TRUE; } break; } } return isFieldXable; }
@Test public void testGenerateFor_defaultToBooleanAnnotationSupplied() { final Element element = avatarRule.getElementWithUniqueId("boolean"); final AnnotationMirror mirror = AnnotationMirrorHelper.getAnnotationMirror(element, DefaultToBoolean.class); final MethodSpec generatedMethod = generator.generateFor(mirror); assertThat(generatedMethod, is(notNullValue())); checkMethodSignature(generatedMethod, ClassName.BOOLEAN.box()); checkCompiles(generatedMethod); }
@Override public MethodSpec supplyFor(final AnnotationMirror useAnno, final int position) { return getBaseMethodSpec(position) .returns(Object.class) .addCode(CodeBlock .builder() .addStatement("return null") .build()) .build(); }
private void addOnStale( @Nonnull final AnnotationMirror annotation, @Nonnull final ExecutableElement method ) throws ArezProcessorException { final String name = deriveHookName( method, ComputedDescriptor.ON_STALE_PATTERN, "Stale", getAnnotationParameter( annotation, "name" ) ); findOrCreateComputed( name ).setOnStale( method ); }
private ImmutableSet<String> buildAnnotations(ExecutableElement element) { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); List<? extends AnnotationMirror> annotations = element.getAnnotationMirrors(); for (AnnotationMirror annotation : annotations) { builder.add(annotation.getAnnotationType() .asElement() .getSimpleName() .toString()); } return builder.build(); }
static void copyDocumentedAnnotations( @Nonnull final AnnotatedConstruct element, @Nonnull final MethodSpec.Builder builder ) { for ( final AnnotationMirror annotation : element.getAnnotationMirrors() ) { final DeclaredType annotationType = annotation.getAnnotationType(); if ( !annotationType.toString().startsWith( "react4j.annotations." ) && null != annotationType.asElement().getAnnotation( Documented.class ) ) { builder.addAnnotation( AnnotationSpec.get( annotation ) ); } } }
private static AnnotationMirror getFirstAnnotationFromGivenSet(TypeElement subject, Collection<String> annotationClasses) { for (String annClass : annotationClasses) { AnnotationMirror foundAnn = Utilities.findAnnotation(subject, annClass); if (foundAnn != null) { return foundAnn; } } return null; }
private ImmutableSet<String> buildAnnotations(ExecutableElement element) { ImmutableSet.Builder<String> builder = ImmutableSet.builder(); List<? extends AnnotationMirror> annotations = element.getAnnotationMirrors(); for (AnnotationMirror annotation : annotations) { builder.add(annotation.getAnnotationType().asElement().getSimpleName().toString()); } return builder.build(); }
@Test public void testGenerateFor_stringHandlerAnnotationSupplied() { final Element element = avatarRule.getElementWithUniqueId("string"); final AnnotationMirror mirror = AnnotationMirrorHelper.getAnnotationMirror(element, StringHandler.class); final MethodSpec generatedMethod = generator.generateFor(mirror); checkSignature(generatedMethod, ClassName.get(String.class)); checkCompiles(generatedMethod); }
private static Set<String> getAnnotations(List<? extends AnnotationMirror> annotations) { Set<String> set = new LinkedHashSet<>(); for (AnnotationMirror annotation : annotations) { set.add(annotation.getAnnotationType().asElement().getSimpleName().toString()); } return Collections.unmodifiableSet(set); }
static StyleableAnnotationValues getStyleableAnnotationValues(final Trees trees, final Elements elementUtils, final Types typeUtils, final Messager messager, final Element annotatedElement) { RClassReference styleableReference = null; RClassReference defaultValueReference = null; AnnotationMirror annotationMirror = null; for (final AnnotationMirror mirror : annotatedElement.getAnnotationMirrors()) { if (mirror.getAnnotationType().toString().equals(Styleable.class.getCanonicalName())) { annotationMirror = mirror; break; } } AnnotationValue value = null; AnnotationValue defaultValue = null; //noinspection ConstantConditions for (final Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : annotationMirror.getElementValues().entrySet()) { if (entry.getKey().getSimpleName().toString().equals("value")) { value = entry.getValue(); } else if (entry.getKey().getSimpleName().toString().equals("defaultRes")) { defaultValue = entry.getValue(); } } styleableReference = getRClassReference(trees, elementUtils, typeUtils, messager, annotatedElement, annotationMirror, value, StyleableField.VALUE_FIELD); if (defaultValue != null) { defaultValueReference = getRClassReference(trees, elementUtils, typeUtils, messager, annotatedElement, annotationMirror, defaultValue, StyleableField.DEFAULT_RES_FIELD); } return new StyleableAnnotationValues(styleableReference, defaultValueReference); }
@Test public void testGetAnnotation_defaultToDimensionResourceAnnotationPresent() { final ExecutableElement element = avatarRule.getElementWithUniqueId("dimension resource"); final AnnotationMirror mirror = DefaultAnnoRetriever.getAnnotation(element); assertThat(mirror, is(notNullValue())); assertThat(mirror.getAnnotationType().toString(), is(DefaultToDimensionResource.class.getName())); }
public static TypeMirror[] getClassArrayAttributeFromAnnotationAsTypeMirror(Element element, Class<? extends Annotation> annotationType, String attributeName) { AnnotationMirror annotationMirror = getAnnotationMirror(element, annotationType); if (annotationMirror == null) { return null; } AnnotationValue annotationAttributeValue = getAnnotationValueOfAttribute(annotationMirror, attributeName); if (annotationAttributeValue == null) { return new TypeMirror[0]; } else { return AnnotationValueUtils.getTypeAttributeValueArray(annotationAttributeValue); } }
@Test public void testGenerateFor_dimensionHandlerAnnotationSupplied() { final Element element = avatarRule.getElementWithUniqueId("dimension"); final AnnotationMirror mirror = AnnotationMirrorHelper.getAnnotationMirror(element, DimensionHandler.class); final MethodSpec generatedMethod = generator.generateFor(mirror); checkSignature(generatedMethod, ClassName.get(Number.class)); checkCompiles(generatedMethod); }
private static Stream<AnnotationMirror> annotationMirrorSearch(final String typeName, final Collection<? extends AnnotationMirror> mirrors) { return Stream.concat( mirrors.stream().filter(mirror -> Objects.equals(typeName, mirror.getAnnotationType().toString())), mirrors.stream() // Only annotations with at least one array parameter .filter(mirror -> mirror.getElementValues().values().stream().anyMatch(AnnotationHelper::isArray)) .flatMap(mirror -> mirror.getElementValues().values().stream() .filter(AnnotationHelper::isArray) // only array parameters... .map(AnnotationHelper::asArray) .filter(list -> list.stream().allMatch(AnnotationHelper::isAnnotation)) // ...whose values are annotations .map(list -> list.stream().map(AnnotationHelper::asAnnotation).collect(Collectors.toList())) .flatMap(list -> annotationMirrorSearch(typeName, list)))); }
@Override public TreePath getPath(Element elmnt, AnnotationMirror am, AnnotationValue av) { if (elmnt == null) { return null; } return delegate.getPath(elmnt, am, av); }
@Nullable private static AnnotationValue findAnnotationValue( @Nonnull final Elements elements, @Nonnull final Element typeElement, @Nonnull final String annotationClassName, @Nonnull final String parameterName ) { final AnnotationMirror mirror = getAnnotationByType( typeElement, annotationClassName ); return findAnnotationValue( elements, mirror, parameterName ); }
private void processMatchRule(EconomicMap<TypeElement, MatchRuleDescriptor> map, Element element, AnnotationMirror mirror) { if (!processedMatchRule.contains(element)) { try { processedMatchRule.add(element); // The annotation element type should ensure this is true. assert element instanceof ExecutableElement; findMatchableNodes(element); TypeElement topDeclaringType = topDeclaringType(element); MatchRuleDescriptor info = map.get(topDeclaringType); if (info == null) { info = new MatchRuleDescriptor(topDeclaringType); map.put(topDeclaringType, info); } List<AnnotationMirror> mirrors = null; if (typeUtils().isSameType(mirror.getAnnotationType(), matchRulesTypeMirror)) { // Unpack the mirrors for a repeatable annotation mirrors = getAnnotationValueList(AnnotationMirror.class, mirror, "value"); } int i = 0; for (MatchRule matchRule : element.getAnnotationsByType(MatchRule.class)) { processMethodMatchRule((ExecutableElement) element, info, matchRule, mirrors != null ? mirrors.get(i++) : mirror); } } catch (Throwable t) { reportExceptionThrow(element, t); } } }
private static AnnotationMirror getMirror(Element element, Class<? extends Annotation> annotation) { for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) { if (annotationMirror.getAnnotationType().toString().equals(annotation.getCanonicalName())) { return annotationMirror; } } return null; }
@Test public void testGenerateFor_parameterWithUseString() { final VariableElement parameter = avatarRule.getElementWithUniqueId("string"); final AnnotationMirror useAnnotation = UseAnnoRetriever.getAnnotation(parameter); final MethodSpec generatedMethod = generator.generateFor(useAnnotation, 0); checkSignature(generatedMethod, ClassName.get(String.class)); checkCompiles(generatedMethod); }
public void testCreateAnnotationBooleanArgumentIssue89230() throws Exception { TestUtilities.copyStringToFileObject(testFO, "package foo;" + "@interface Column {" + " boolean nullable();" + "}" + "public class TestClass {" + "}"); runModificationTask(testFO, new Task<WorkingCopy>() { public void run(WorkingCopy copy) throws Exception { GenerationUtils genUtils = GenerationUtils.newInstance(copy); ClassTree classTree = SourceUtils.getPublicTopLevelTree(copy); AnnotationTree annotationTree = genUtils.createAnnotation("foo.Column", Collections.singletonList(genUtils.createAnnotationArgument("nullable", true))); ClassTree newClassTree = genUtils.addAnnotation(classTree, annotationTree); copy.rewrite(classTree, newClassTree); } }).commit(); runUserActionTask(testFO, new Task<CompilationController>() { public void run(CompilationController controller) throws Exception { TypeElement typeElement = SourceUtils.getPublicTopLevelElement(controller); assertEquals(1, typeElement.getAnnotationMirrors().size()); AnnotationMirror columnAnn = typeElement.getAnnotationMirrors().get(0); assertEquals(1, columnAnn.getElementValues().size()); Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> columnAnnNullableElement = columnAnn.getElementValues().entrySet().iterator().next(); assertEquals("nullable", columnAnnNullableElement.getKey().getSimpleName().toString()); assertEquals(true, columnAnn.getElementValues().values().iterator().next().getValue()); } }); }
@Override public void verify(Element element, AnnotationMirror classSubstitution, PluginGenerator generator) { if (!element.getKind().isClass()) { assert false : "Element is guaranteed to be a class."; return; } TypeElement type = (TypeElement) element; TypeElement substitutionType = resolveOriginalType(env, type, classSubstitution); if (substitutionType == null) { return; } }
private TypeMirror[] originalSignature(TypeElement originalType, ExecutableElement method, AnnotationMirror annotation, boolean isStatic) { AnnotationValue signatureValue = findAnnotationValue(annotation, ORIGINAL_SIGNATURE); String signatureString = resolveAnnotationValue(String.class, signatureValue); List<TypeMirror> parameters = new ArrayList<>(); if (signatureString.equals(ORIGINAL_SIGNATURE_DEFAULT)) { for (int i = 0; i < method.getParameters().size(); i++) { parameters.add(method.getParameters().get(i).asType()); } if (!isStatic) { if (parameters.isEmpty()) { env.getMessager().printMessage(Kind.ERROR, "Method signature must be a static method with the 'this' object as its first parameter", method, annotation); return null; } else { TypeMirror thisParam = parameters.remove(0); if (!isSubtype(originalType.asType(), thisParam)) { Name thisName = method.getParameters().get(0).getSimpleName(); env.getMessager().printMessage(Kind.ERROR, String.format("The type of %s must assignable from %s", thisName, originalType), method, annotation); } } } parameters.add(0, method.getReturnType()); } else { try { APHotSpotSignature signature = new APHotSpotSignature(signatureString); parameters.add(signature.getReturnType(env)); for (int i = 0; i < signature.getParameterCount(false); i++) { parameters.add(signature.getParameterType(env, i)); } } catch (Exception e) { /* * That's not good practice and should be changed after APHotSpotSignature has * received a cleanup. */ env.getMessager().printMessage(Kind.ERROR, String.format("Parsing the signature failed: %s", e.getMessage() != null ? e.getMessage() : e.toString()), method, annotation, signatureValue); return null; } } return parameters.toArray(new TypeMirror[parameters.size()]); }
private void addOnDeactivate( @Nonnull final AnnotationMirror annotation, @Nonnull final ExecutableElement method ) throws ArezProcessorException { final String name = deriveHookName( method, ComputedDescriptor.ON_DEACTIVATE_PATTERN, "Deactivate", getAnnotationParameter( annotation, "name" ) ); findOrCreateComputed( name ).setOnDeactivate( method ); }
private MethodSpec generateRequestOptionOverride(ExecutableElement methodToOverride) { MethodSpec.Builder result = ProcessorUtil.overriding(methodToOverride) .returns(glideOptionsName) .addModifiers(Modifier.FINAL) .addCode(CodeBlock.builder() .add("return ($T) super.$N(", glideOptionsName, methodToOverride.getSimpleName()) .add(FluentIterable.from(methodToOverride.getParameters()) .transform(new Function<VariableElement, String>() { @Override public String apply(VariableElement input) { return input.getSimpleName().toString(); } }) .join(Joiner.on(", "))) .add(");\n") .build()); if (methodToOverride.getSimpleName().toString().equals("transforms")) { result .addAnnotation(SafeVarargs.class) .addAnnotation( AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "$S", "varargs") .build()); } for (AnnotationMirror mirror : methodToOverride.getAnnotationMirrors()) { result.addAnnotation(AnnotationSpec.get(mirror)); } return result.build(); }
private void addAction( @Nonnull final AnnotationMirror annotation, @Nonnull final ExecutableElement method, @Nonnull final ExecutableType methodType ) throws ArezProcessorException { MethodChecks.mustBeOverridable( Constants.ACTION_ANNOTATION_CLASSNAME, method ); final String name = deriveActionName( method, annotation ); checkNameUnique( name, method, Constants.ACTION_ANNOTATION_CLASSNAME ); final boolean mutation = getAnnotationParameter( annotation, "mutation" ); final boolean reportParameters = getAnnotationParameter( annotation, "reportParameters" ); final ActionDescriptor action = new ActionDescriptor( this, name, mutation, reportParameters, method, methodType ); _actions.put( action.getName(), action ); }
@Test public void testGetAnnotation_useBooleanAnnotationPresent() { final VariableElement element = avatarRule.getElementWithUniqueId("boolean"); final AnnotationMirror mirror = UseAnnoRetriever.getAnnotation(element); assertThat(mirror, is(notNullValue())); assertThat(mirror.getAnnotationType().toString(), is(UseBoolean.class.getName())); }
boolean refresh(TypeElement typeElement) { class2 = typeElement.getQualifiedName().toString(); AnnotationModelHelper helper = getHelper(); Map<String, ? extends AnnotationMirror> annByType = helper.getAnnotationsByType(typeElement.getAnnotationMirrors()); AnnotationMirror embeddableAnn = annByType.get("javax.persistence.Embeddable"); // NOI18N return embeddableAnn != null; }
@Override public MethodSpec supplyFor(final AnnotationMirror anno) { final CodeBlock body = CodeBlock .builder() .addStatement("return $L", getLiteralFromAnnotation(anno, "value")) .build(); return getBaseMethodSpec() .returns(Number.class) .addCode(body) .build(); }
