private void emitResolvedOptionalSequence(TypeSpec.Builder intentBuilderTypeBuilder) { // find superclass final ClassName optionalSequence = get(target.classPackage, builderClassName(), OPTIONAL_SEQUENCE_CLASS); final ClassName resolvedOptional = get(target.classPackage, builderClassName(), RESOLVED_OPTIONAL_SEQUENCE_CLASS); TypeSpec.Builder resolvedOptionalSequenceBuilder = TypeSpec.classBuilder(RESOLVED_OPTIONAL_SEQUENCE_CLASS) .superclass(ParameterizedTypeName.get(optionalSequence, resolvedOptional)) .addModifiers(Modifier.PUBLIC) .addModifiers(Modifier.STATIC); MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(Bundler.class, "bundler") .addParameter(get("android.content", "Intent"), "intent") .addStatement("super(bundler, intent)"); resolvedOptionalSequenceBuilder.addMethod(constructorBuilder.build()); intentBuilderTypeBuilder.addType(resolvedOptionalSequenceBuilder.build()); }
Strings.lowercaseFirstLetter(functionName) + "EventFlowable"; ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(ClassName.get(Flowable.class), ClassName.get("", responseClassName)); MethodSpec.methodBuilder(generatedFunctionName) .addModifiers(Modifier.PUBLIC) .addParameter(EthFilter.class, FILTER) .returns(parameterizedTypeName); TypeSpec converter = TypeSpec.anonymousClassBuilder("") .addSuperinterface(ParameterizedTypeName.get( ClassName.get(io.reactivex.functions.Function.class), ClassName.get(Log.class), ClassName.get("", responseClassName))) .addMethod(MethodSpec.methodBuilder("apply") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addStatement("return typedResponse") .build()) .build();
private void createBuilderInterface(@NonNull List<Element> elements) throws IOException { final TypeSpec.Builder interfaceBuilder = TypeSpec.interfaceBuilder(builderVisibleName) .addModifiers(Modifier.PUBLIC) .addSuperinterface(ConfigurationBuilder.class); final TypeName baseAnnotation = TypeName.get(this.baseAnnotation.asType()); Strings.addClassJavadoc(interfaceBuilder, baseAnnotation); ClassName builder = ClassName.get(PACKAGE, builderVisibleName); elements.stream().filter(BuilderElement.Interface.class::isInstance).map(BuilderElement.Interface.class::cast) .forEach(element -> element.addToBuilderInterface(interfaceBuilder, builder)); Strings.writeClass(processingEnv.getFiler(), interfaceBuilder.build()); }
private void createConfigClass(@NonNull List<Element> elements) throws IOException { final TypeSpec.Builder classBuilder = TypeSpec.classBuilder(configName) .addSuperinterface(Serializable.class) .addSuperinterface(org.acra.config.Configuration.class) .addModifiers(Modifier.PUBLIC, Modifier.FINAL); Strings.addClassJavadoc(classBuilder, ClassName.get(baseAnnotation.asType())); final MethodSpec.Builder constructor = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC) .addParameter(ParameterSpec.builder(ClassName.get(PACKAGE, builderName), PARAM_0).addAnnotation(Types.NON_NULL).build()); elements.stream().filter(ConfigElement.class::isInstance).map(ConfigElement.class::cast).forEach(element -> element.addToConfig(classBuilder, constructor)); classBuilder.addMethod(constructor.build()); Strings.writeClass(processingEnv.getFiler(), classBuilder.build()); }
private TypeSpec builderInterfaceSpec() { return TypeSpec.interfaceBuilder("Builder") .addModifiers(Modifier.PUBLIC) .addSuperinterface(ClassName.get(AwsRequest.class).nestedClass("Builder")) .addMethod(MethodSpec.methodBuilder("build") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT) .returns(className()) .build()) .build(); }
private TypeSpec enumAdapter(ClassName javaType, ClassName adapterJavaType) { return TypeSpec.classBuilder(adapterJavaType.simpleName()) .superclass(enumAdapterOf(javaType)) .addModifiers(PRIVATE, STATIC, FINAL) .addMethod(MethodSpec.constructorBuilder() .addStatement("super($T.class)", javaType) .build()) .addMethod(MethodSpec.methodBuilder("fromValue") .addAnnotation(Override.class) .addModifiers(PROTECTED) .returns(javaType) .addParameter(int.class, "value") .addStatement("return $T.fromValue(value)", javaType) .build()) .build(); }
private void generateTraversalInterface(final Context ctx) throws IOException { final TypeSpec.Builder traversalInterface = TypeSpec.interfaceBuilder(ctx.traversalClazz) .addModifiers(Modifier.PUBLIC) .addTypeVariables(Arrays.asList(TypeVariableName.get("S"), TypeVariableName.get("E"))) .addSuperinterface(TypeName.get(ctx.annotatedDslType.asType())); // process the methods of the GremlinDsl annotated class for (ExecutableElement templateMethod : findMethodsOfElement(ctx.annotatedDslType, null)) { traversalInterface.addMethod(constructMethod(templateMethod, ctx.traversalClassName, ctx.dslName, Modifier.PUBLIC, Modifier.DEFAULT)); } // process the methods of GraphTraversal final TypeElement graphTraversalElement = elementUtils.getTypeElement(GraphTraversal.class.getCanonicalName()); final Predicate<ExecutableElement> ignore = e -> e.getSimpleName().contentEquals("asAdmin") || e.getSimpleName().contentEquals("iterate"); for (ExecutableElement templateMethod : findMethodsOfElement(graphTraversalElement, ignore)) { traversalInterface.addMethod(constructMethod(templateMethod, ctx.traversalClassName, ctx.dslName, Modifier.PUBLIC, Modifier.DEFAULT)); } // there are weird things with generics that require this method to be implemented if it isn't already present // in the GremlinDsl annotated class extending from GraphTraversal traversalInterface.addMethod(MethodSpec.methodBuilder("iterate") .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT) .addAnnotation(Override.class) .addStatement("$T.super.iterate()", ClassName.get(ctx.annotatedDslType)) .addStatement("return this") .returns(ParameterizedTypeName.get(ctx.traversalClassName, TypeVariableName.get("S"), TypeVariableName.get("E"))) .build()); final JavaFile traversalJavaFile = JavaFile.builder(ctx.packageName, traversalInterface.build()).build(); traversalJavaFile.writeTo(filer); }
@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(); }
public TypeSpec generate() { TypeSpec.Builder enumBuilder = TypeSpec.enumBuilder(ProcessUtils.getObjectName(element) + Constants.ENUM_COLUMN_SUFFIX) .addModifiers(Modifier.PUBLIC) .addField(String.class, Constants.ENUM_COLUMN_ELEMENT_NAME, Modifier.PRIVATE, Modifier.FINAL) .addField(TypeName.BOOLEAN, Constants.ENUM_COLUMN_IS_PRIMITIVE, Modifier.PRIVATE, Modifier.FINAL) .addMethod(MethodSpec.methodBuilder("getName") .addModifiers(Modifier.PUBLIC) .returns(TypeName.get(String.class)) .addStatement("return this.$L", Constants.ENUM_COLUMN_ELEMENT_NAME) .build()) .addMethod(MethodSpec.methodBuilder("isPrimitive") .addModifiers(Modifier.PUBLIC) .returns(TypeName.BOOLEAN) .addStatement("return this.$L", Constants.ENUM_COLUMN_IS_PRIMITIVE) .build()) .addMethod(MethodSpec.constructorBuilder() .addParameter(String.class, "name") .addParameter(TypeName.BOOLEAN, "primitive") fieldSqlName = Constants.FIELD_ID; boolean isPrimivive = ProcessUtils.isPrimitive(variableElement); enumBuilder.addEnumConstant(ProcessUtils.getObjectName(variableElement), TypeSpec.anonymousClassBuilder("$S, $L", fieldSqlName, isPrimivive) .build());
@Override protected TypeSpec.Builder createClassBuilder() { ClassName parentClassName = getClassDetail().getGeneratedClassName(); ClassName generatedClassName = ClassName.get( getClassDetail().getPackageName(), getClassDetail().getTypeName() + BindingSuffix.CLASS_LOAD_MORE_VIEW_BINDER_SUFFIX); ClassName loadMoreCallbackClassName = ClassName.get( NameStore.Package.PLACE_HOLDER_VIEW, NameStore.Class.LOAD_MORE_CALLBACK_BINDER); return TypeSpec.classBuilder(generatedClassName) .superclass(parentClassName) .addSuperinterface(ParameterizedTypeName.get(loadMoreCallbackClassName, TypeVariableName.get(getClassDetail().getTypeElement().asType()))) .addModifiers(Modifier.PUBLIC) .addAnnotation(Keep.class); }
TypeSpec.Builder typeBuilder; if (typeToExtend.isInterface()) { typeBuilder = TypeSpec.interfaceBuilder(newTypeName); } else { typeBuilder = TypeSpec.classBuilder(newTypeName); typeBuilder.addTypeVariables(typeToExtend.getTypeParameterElements() .stream() .map(TypeVariableName::get) typeBuilder.addModifiers(Modifier.PUBLIC); typeBuilder.addSuperinterface(TypeName.get(typeMirror)); } else { typeBuilder.superclass(TypeName.get(typeMirror)).addModifiers(Modifier.ABSTRACT); typeBuilder.addMethod(constructorBuilder.build()); .methodBuilder(DELEGATE_METHOD) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT) .returns(TypeName.get(typeMirror)); .overriding(methodElement) .addStatement(callFormat, callArgs); if (typeToExtend.isInterface()) {
static TypeSpec generateStateContainer(SpecModel specModel) { final TypeSpec.Builder stateContainerClassBuilder = TypeSpec.classBuilder(getStateContainerClassName(specModel)) .addSuperinterface(specModel.getStateContainerClass()) .addAnnotation( AnnotationSpec.builder(VisibleForTesting.class) .addMember("otherwise", "$L", VisibleForTesting.PRIVATE) .build()) .addModifiers(Modifier.STATIC) .addTypeVariables(specModel.getTypeVariables()); stateContainerClassBuilder.addField( FieldSpec.builder( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box()), GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME) .initializer("new $T<>()", ClassNames.ARRAY_LIST) stateContainerClassBuilder.addMethod( MethodSpec.methodBuilder("consumeTransitions") .addModifiers(Modifier.PUBLIC) .addAnnotation(Override.class) .returns( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box())) .addCode( CodeBlock.builder()
/** * Write a companion class for {@code type} that extends {@link StaticInjection}. */ private void generateStaticInjection(TypeElement type, List<Element> fields) throws IOException { ClassName typeName = ClassName.get(type); ClassName adapterClassName = adapterName(ClassName.get(type), STATIC_INJECTION_SUFFIX); TypeSpec.Builder result = TypeSpec.classBuilder(adapterClassName.simpleName()) .addOriginatingElement(type) .addJavadoc(AdapterJavadocs.STATIC_INJECTION_TYPE, type) .addModifiers(PUBLIC, FINAL) .superclass(StaticInjection.class); for (Element field : fields) { result.addField(memberBindingField(false, field)); } result.addMethod(attachMethod(null, fields, false, typeName, null, true)); result.addMethod(staticInjectMethod(fields, typeName)); String packageName = getPackage(type).getQualifiedName().toString(); JavaFile javaFile = JavaFile.builder(packageName, result.build()) .addFileComment(AdapterJavadocs.GENERATED_BY_DAGGER) .build(); javaFile.writeTo(processingEnv.getFiler()); }
private static <T extends SpecModel & HasEnclosedSpecModel> MethodSpec generateBuildMethod( final T specModel) { final MethodSpec.Builder buildMethodBuilder = MethodSpec.methodBuilder("build") .addModifiers(Modifier.PUBLIC) .returns(getMatcherConditionTypeName()); final CodeBlock innerMatcherLogicBlock = generateMatchMethodBody(specModel); final TypeSpec matcherInnerClass = TypeSpec.anonymousClassBuilder("") .superclass(getMatcherConditionTypeName()) .addMethod( MethodSpec.methodBuilder("matches") .addModifiers(Modifier.PUBLIC) .addParameter(ClassNames.INSPECTABLE_COMPONENT, "value") .returns(TypeName.BOOLEAN) .addAnnotation(Override.class) .addCode(innerMatcherLogicBlock) .build()) .build(); return buildMethodBuilder .addStatement("final $T mainBuilder = $L", getMatcherConditionTypeName(), matcherInnerClass) .addStatement( "return $T.allOf(mainBuilder, $T.buildCommonMatcher(this))", ClassNames.ASSERTJ_JAVA6ASSERTIONS, ClassNames.BASE_MATCHER_BUILDER) .build(); }
ClassName javaType = (ClassName) typeName(type.type()); TypeSpec.Builder builder = TypeSpec.enumBuilder(javaType.simpleName()) .addModifiers(PUBLIC) .addSuperinterface(WireEnum.class); builder.addJavadoc("$L\n", sanitizeJavadoc(type.documentation())); builder.addField(TypeName.INT, value, PRIVATE, FINAL); MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder(); constructorBuilder.addStatement("this.$1N = $1N", value); constructorBuilder.addParameter(TypeName.INT, value); builder.addMethod(constructorBuilder.build()); MethodSpec.Builder fromValueBuilder = MethodSpec.methodBuilder("fromValue") .addJavadoc("Return the constant for {@code $N} or null.\n", value) .addModifiers(PUBLIC, STATIC) TypeSpec.Builder constantBuilder = TypeSpec.anonymousClassBuilder(enumArgsFormat, enumArgs); if (!constant.documentation().isEmpty()) { constantBuilder.addJavadoc("$L\n", sanitizeJavadoc(constant.documentation())); ClassName adapterJavaType = javaType.nestedClass("ProtoAdapter_" + javaType.simpleName()); if (!emitCompact) { adapterBuilder.initializer("new $T()", adapterJavaType);
@Override public void output(CodeContainer<TypeSpec.Builder> rootDirectory, BuildPhase buildPhase) throws IOException { if (buildPhase != INTERFACE) { return; } FieldSpec.Builder field = FieldSpec.builder(ClassName.get(String.class), "name").addModifiers(Modifier.PRIVATE); build.withTypeListeners().onEnumField(build, field, typeDeclaration); TypeSpec.Builder enumBuilder = TypeSpec.enumBuilder(javaName) .addField(field.build()) .addModifiers(Modifier.PUBLIC) .addMethod( MethodSpec.constructorBuilder().addParameter(ClassName.get(String.class), "name") .addStatement("this.$N = $N", "name", "name") .build() ); build.withTypeListeners().onEnumerationClass(build, enumBuilder, typeDeclaration); for (String value : values) { TypeSpec.Builder builder = TypeSpec.anonymousClassBuilder("$S", value); build.withTypeListeners().onEnumConstant(build, builder, typeDeclaration, value); enumBuilder.addEnumConstant(Names.constantName(value), builder.build()); } rootDirectory.into(enumBuilder); }
private void createFactoryClass() throws IOException { final TypeName configurationBuilderFactory = Types.CONFIGURATION_BUILDER_FACTORY; Strings.writeClass(processingEnv.getFiler(), TypeSpec.classBuilder(factoryName) .addModifiers(Modifier.PUBLIC) .addSuperinterface(configurationBuilderFactory) .addAnnotation(AnnotationSpec.builder(AutoService.class).addMember("value", "$T.class", configurationBuilderFactory).build()) .addMethod(Types.overriding(Types.getOnlyMethod(processingEnv, Strings.CONFIGURATION_BUILDER_FACTORY)) .addAnnotation(Types.NON_NULL) .addStatement("return new $T($L)", ClassName.get(PACKAGE, builderName), PARAM_0) .build()) .build()); } }
private static <T extends SpecModel & HasEnclosedSpecModel> TypeSpecDataHolder generateBuilder( final T specModel) { final TypeSpec.Builder propsBuilderClassBuilder = TypeSpec.classBuilder(BUILDER) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .superclass( ParameterizedTypeName.get(ClassNames.BASE_MATCHER, getMatcherType(specModel))) .addField( FieldSpec.builder( ClassNames.RESOURCE_RESOLVER, RESOURCE_RESOLVER, Modifier.PROTECTED) MethodSpec.constructorBuilder() .addParameter(specModel.getContextClass(), "c") .addStatement("$L = new $T(c)", RESOURCE_RESOLVER, ClassNames.RESOURCE_RESOLVER) .build(); propsBuilderClassBuilder.addMethod(constructor);
private TypeSpec generateEnclosingType(EnclosingType type) { ClassName javaType = (ClassName) typeName(type.type()); TypeSpec.Builder builder = TypeSpec.classBuilder(javaType.simpleName()) .addModifiers(PUBLIC, FINAL); if (javaType.enclosingClassName() != null) { builder.addModifiers(STATIC); } String documentation = type.documentation(); if (!documentation.isEmpty()) { documentation += "\n\n<p>"; } documentation += "<b>NOTE:</b> This type only exists to maintain class structure" + " for its nested types and is not an actual message."; builder.addJavadoc("$L\n", documentation); builder.addMethod(MethodSpec.constructorBuilder() .addModifiers(PRIVATE) .addStatement("throw new $T()", AssertionError.class) .build()); for (Type nestedType : type.nestedTypes()) { builder.addType(generateType(nestedType)); } return builder.build(); }
static TypeSpec generatePreviousRenderDataContainerImpl(SpecModel specModel) { final String className = RenderDataGenerator.getRenderDataImplClassName(specModel); final TypeSpec.Builder renderInfoClassBuilder = TypeSpec.classBuilder(className).addSuperinterface(ClassNames.RENDER_DATA); renderInfoClassBuilder.addModifiers(Modifier.STATIC, Modifier.PRIVATE); renderInfoClassBuilder.addTypeVariables(specModel.getTypeVariables()); final MethodSpec.Builder copyBuilder = MethodSpec.methodBuilder("copy") .addParameter(ClassName.bestGuess(className), copyParamName); final MethodSpec.Builder recordBuilder = MethodSpec.methodBuilder("record") .addParameter(specModel.getComponentTypeName(), recordParamName); copyBuilder.addStatement("$L = $L.$L", name, copyParamName, name); recordBuilder.addStatement( "$L = $L.$L",