methodBuilder.addStatement("throw new RuntimeException" + "(\"cannot call constant function with void return type\")"); } else if (outputParameterTypes.size() == 1) { nativeReturnTypeName = getWrapperType(typeName); methodBuilder.returns(buildRemoteCall(nativeReturnTypeName)); methodBuilder.addStatement("final $T function = " + "new $T($N, \n$T.<$T>asList($L), " + "\n$T.<$T<?>>asList(new $T<$T>() {}))", .addSuperinterface(ParameterizedTypeName.get( ClassName.get(Callable.class), nativeReturnTypeName)) .addMethod(MethodSpec.methodBuilder("call") .addAnnotation(Override.class) .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "$S", "unchecked") .build()) .addModifiers(Modifier.PUBLIC) .addException(Exception.class) .addCode(callCode.build()) .build()) .build(); methodBuilder.addStatement("return new $T(\n$L)",
public static AnnotationSpec get(Annotation annotation, boolean includeDefaultValues) { Builder builder = builder(annotation.annotationType()); try { Method[] methods = annotation.annotationType().getDeclaredMethods(); Arrays.sort(methods, Comparator.comparing(Method::getName)); for (Method method : methods) { Object value = method.invoke(annotation); if (!includeDefaultValues) { if (Objects.deepEquals(value, method.getDefaultValue())) { continue; } } if (value.getClass().isArray()) { for (int i = 0; i < Array.getLength(value); i++) { builder.addMemberForValue(method.getName(), Array.get(value, i)); } continue; } if (value instanceof Annotation) { builder.addMember(method.getName(), "$L", get((Annotation) value)); continue; } builder.addMemberForValue(method.getName(), value); } } catch (Exception e) { throw new RuntimeException("Reflecting " + annotation + " failed!", e); } return builder.build(); }
public AnnotationSpec build() { return new AnnotationSpec(this); } }
public static Builder builder(Class<?> type) { return builder(ClassName.get(type)); }
@Override public void enterRule(Rule rule) { // generates a new ephemeral unique class name for each generated rule. Only valid for the runtime of the jvm classFile = TypeSpec.classBuilder("rule$" + rule.id()) .addSuperinterface(GeneratedRule.class) .addModifiers(Modifier.FINAL, Modifier.PUBLIC) .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "$S", "unchecked") .build() ) .addMethod(MethodSpec.methodBuilder("name") .returns(String.class) .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addStatement("return $S", rule.name()) .build() ); constructorBuilder = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(FunctionRegistry.class, "functionRegistry"); lateConstructorBlock = CodeBlock.builder(); hoistedConstantExpressions = CodeBlock.builder(); }
private MethodSpec createBindingConstructor(int sdk, boolean debuggable) { MethodSpec.Builder constructor = MethodSpec.constructorBuilder() .addAnnotation(UI_THREAD) .addModifiers(PUBLIC); constructor.addParameter(targetTypeName, "target", FINAL); } else { constructor.addParameter(targetTypeName, "target"); constructor.addAnnotation(AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "$S", "ResourceType") .build()); constructor.addAnnotation(AnnotationSpec.builder(SUPPRESS_LINT) .addMember("value", "$S", "ClickableViewAccessibility") .build());
private MethodSpec setter(final Descriptor d, final ExecutableElement field) { String fieldName = fieldName(field); ParameterSpec.Builder parameterSpecBuilder = ParameterSpec.builder(fieldType(d, field), fieldName); if (!isPrimitive(field)) { AnnotationMirror nullableAnnotation = nullableAnnotation(field); if (nullableAnnotation != null) { parameterSpecBuilder.addAnnotation(AnnotationSpec.get(nullableAnnotation)); } } MethodSpec.Builder setter = MethodSpec.methodBuilder(fieldName) .addModifiers(PUBLIC) .addParameter(parameterSpecBuilder.build()) .returns(builderType(d)); if (shouldEnforceNonNull(field)) { assertNotNull(setter, fieldName); } setter.addStatement("this.$N = $N", fieldName, fieldName); return setter.addStatement("return this").build(); }
private MethodSpec generateGetterMethod(String name, ExecutableElement element) { final TypeName returnType = ClassName.get(element.getReturnType()); final String prefix = isBoolean(returnType) ? "is" : "get"; final String getterName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, name); final MethodSpec.Builder builder = MethodSpec.methodBuilder(prefix + getterName) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addAnnotation(AnnotationSpec.builder(JsonIgnore.class).build()) .addStatement("return $N()", name) .returns(returnType); // Copy all annotations but @JsonProperty, @JsonIgnore, and @Override to the new method. for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) { final TypeName annotationType = ClassName.get(annotationMirror.getAnnotationType()); if (SKIP_ANNOTATIONS.contains(annotationType)) { continue; } builder.addAnnotation(AnnotationSpec.get(annotationMirror)); } return builder.build(); }
private void addConstructorAndProviderFields( TypeSpec.Builder factory, FactoryDescriptor descriptor) { MethodSpec.Builder constructor = constructorBuilder().addAnnotation(Inject.class); if (descriptor.publicType()) { constructor.addModifiers(PUBLIC); } Iterator<ProviderField> providerFields = descriptor.providers().values().iterator(); for (int argumentIndex = 1; providerFields.hasNext(); argumentIndex++) { ProviderField provider = providerFields.next(); TypeName typeName = TypeName.get(provider.key().type()).box(); TypeName providerType = ParameterizedTypeName.get(ClassName.get(Provider.class), typeName); factory.addField(providerType, provider.name(), PRIVATE, FINAL); if (provider.key().qualifier().isPresent()) { // only qualify the constructor parameter providerType = providerType.annotated(AnnotationSpec.get(provider.key().qualifier().get())); } constructor.addParameter(providerType, provider.name()); constructor.addStatement("this.$1L = checkNotNull($1L, $2L)", provider.name(), argumentIndex); } factory.addMethod(constructor.build()); }
@Override public MethodSpec buildSetter(RDFSClazz domainClazz, OntGenerationConfig config) throws RepositoryException { // @Iri annotation of the property: AnnotationSpec iriAnnotation = AnnotationSpec.builder(Iri.class) .addMember("value", "$S", getResourceAsString()) .build(); // Get the signature of a setter for this property: MethodSpec signature = buildSignature(domainClazz, config); if (signature != null) { // Add an abstract modifier to the signature: return signature.toBuilder() .addModifiers(Modifier.ABSTRACT) .addAnnotation(iriAnnotation) .build(); } else { return null; } } }
public static AnnotationSpec get(Annotation annotation) { return get(annotation, false); }
private TypeSpec getTypeSpec() { TypeSpec.Builder builder = TypeSpec.classBuilder(mJsonObjectHolder.injectedClassName).addModifiers(Modifier.PUBLIC, Modifier.FINAL); builder.addAnnotation(AnnotationSpec.builder(SuppressWarnings.class).addMember("value", "\"unsafe,unchecked\"").build()); builder.superclass(ParameterizedTypeName.get(ClassName.get(JsonMapper.class), mJsonObjectHolder.objectTypeName)); MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC); List<String> createdJsonMappers = new ArrayList<>(); constructorBuilder.addParameter(ClassName.get(ParameterizedType.class), "type"); constructorBuilder.addStatement("partialMappers.put(type, this)");
private MethodSpec setter(final Descriptor d, final ExecutableElement field) { String fieldName = fieldName(field); ParameterSpec.Builder parameterSpecBuilder = ParameterSpec.builder(fieldType(d, field), fieldName); if (!isPrimitive(field)) { AnnotationMirror nullableAnnotation = nullableAnnotation(field); if (nullableAnnotation != null) { parameterSpecBuilder.addAnnotation(AnnotationSpec.get(nullableAnnotation)); } } MethodSpec.Builder setter = MethodSpec.methodBuilder(fieldName) .addModifiers(PUBLIC) .addParameter(parameterSpecBuilder.build()) .returns(builderType(d)); if (shouldEnforceNonNull(field)) { assertNotNull(setter, fieldName); } setter.addStatement("this.$N = $N", fieldName, fieldName); return setter.addStatement("return this").build(); }
@Override public MethodSpec buildGetter(RDFSClazz domainClazz, OntGenerationConfig config) throws RepositoryException { // @Iri annotation of the property: AnnotationSpec iriAnnotation = AnnotationSpec.builder(Iri.class) .addMember("value", "$S", getResourceAsString()) .build(); return buildSignature(domainClazz, config) .toBuilder() .addModifiers(Modifier.ABSTRACT) .addAnnotation(iriAnnotation) .addAnnotations(buildSchemaAnnotations(domainClazz, config)) .build(); } }
.build(); MethodSpec parseMethod = MethodSpec.methodBuilder("parseUri") .addModifiers(Modifier.PUBLIC) .addAnnotation(AnnotationSpec.builder(Override.class).build()) .addParameter(String.class, "uri") .returns(DeepLinkEntry.class) .beginControlFlow("for (DeepLinkEntry entry : REGISTRY)") .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addSuperinterface(ClassName.get(Parser.class)) .addField(registry) .addMethod(parseMethod) .build();
static MethodSpec generateEmptyFirebaseValueConstructor() { return MethodSpec.constructorBuilder() .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class) .addMember("value", "\"unused\"") .build()).build(); }
protected static List<ParameterSpec> buildParamSpecs(List<? extends VariableElement> params) { List<ParameterSpec> result = new ArrayList<>(); for (VariableElement param : params) { Builder builder = ParameterSpec.builder(TypeName.get(param.asType()), param.getSimpleName().toString()); for (AnnotationMirror annotation : param.getAnnotationMirrors()) { builder.addAnnotation(AnnotationSpec.get(annotation)); } result.add(builder.build()); } return result; }