private TypeSpec.Builder skeletonType(TypeSpec completeType) { TypeSpec.Builder skeleton = classBuilder(completeType.name) .addSuperinterfaces(completeType.superinterfaces) .addTypeVariables(completeType.typeVariables) .addModifiers(completeType.modifiers.toArray(new Modifier[0])) .addAnnotations(completeType.annotations); if (!completeType.superclass.equals(ClassName.OBJECT)) { skeleton.superclass(completeType.superclass); } completeType.methodSpecs.stream() .filter(method -> !method.modifiers.contains(PRIVATE) || method.isConstructor()) .map(this::skeletonMethod) .forEach(skeleton::addMethod); completeType.fieldSpecs.stream() .filter(field -> !field.modifiers.contains(PRIVATE)) .map(this::skeletonField) .forEach(skeleton::addField); completeType.typeSpecs.stream() .map(type -> skeletonType(type).build()) .forEach(skeleton::addType); return skeleton; }
@Nonnull @Override public TypeSpec create() { final TypeSpec.Builder builder = TypeSpec.classBuilder(getName()); builder.addAnnotations(getAnnotations()); getModifiers().forEach(builder::addModifiers); getSuperClass().ifPresent(builder::superclass); getInterfaces().forEach(builder::addSuperinterface); builder.addFields(getFields()); getMethods().forEach(builder::addMethod); getEnclosedTypes().forEach(builder::addType); return builder.build(); } }
public TypeSpec build() { TypeSpec.Builder builder; switch (kind) { case ANNOTATION: builder = TypeSpec.annotationBuilder(name); break; case CLASS: builder = TypeSpec.classBuilder(name); break; case ENUM: builder = TypeSpec.enumBuilder(name); break; case INTERFACE: builder = TypeSpec.interfaceBuilder(name); break; default: throw new UnsupportedOperationException("Unknown kind: " + kind); } builder.addAnnotations(annotations) .addModifiers(modifiers.toArray(new Modifier[0])) .addTypeVariables(typeVariables) .superclass(superclass) .addSuperinterfaces(superinterfaces); enumConstants.forEach(builder::addEnumConstant); builder.addFields(fieldSpecs).addMethods(methodSpecs).addTypes(typeSpecs); originatingElements.forEach(builder::addOriginatingElement); return builder.build(); }
@Override public String generateClass(Context context, String classNameString, String classToExtend, boolean isFinal) { String packageName = context.packageName(); typeUtils = context.processingEnvironment().getTypeUtils(); TypeElement autoValueTypeElement = context.autoValueClass(); Map<String, ExecutableElement> properties = context.properties(); LinkedHashMap<String, TypeName> types = convertPropertiesToTypes(properties); ClassName className = ClassName.get(packageName, classNameString); TypeSpec firebaseValue = TypeSpec.classBuilder(FIREBASEVALUE) .addModifiers(STATIC, FINAL) .addAnnotations(generateFirebaseValueClassAnnotations(autoValueTypeElement)) .addFields(generateFirebaseValueFields(packageName, types)) .addFields(generateAdapterFields(types)) .addMethod(generateEmptyFirebaseValueConstructor()) .addMethod(generateFirebaseValueConstructorWithAutoValueParam( packageName, autoValueTypeElement, types)) .addMethod(generateFirebaseValueToAutoValueMethod( packageName, className, types)) .addMethod(generateToMapMethod(properties)) .addMethods(generateFirebaseValueGetters(packageName, properties)) .build(); TypeSpec generatedClass = TypeSpec.classBuilder(className) .superclass(TypeVariableName.get(classToExtend)) .addMethod(generateStandardAutoValueConstructor(types)) .addType(firebaseValue) .addModifiers(isFinal ? FINAL : ABSTRACT) .build(); return JavaFile.builder(packageName, generatedClass).build().toString(); }
public TypeSpec build() { TypeSpec.Builder builder; switch (kind) { case ANNOTATION: builder = TypeSpec.annotationBuilder(name); break; case CLASS: builder = TypeSpec.classBuilder(name); break; case ENUM: builder = TypeSpec.enumBuilder(name); break; case INTERFACE: builder = TypeSpec.interfaceBuilder(name); break; default: throw new UnsupportedOperationException("Unknown kind: " + kind); } builder.addAnnotations(annotations) .addModifiers(modifiers.toArray(new Modifier[0])) .addTypeVariables(typeVariables) .superclass(superclass) .addSuperinterfaces(superinterfaces); enumConstants.forEach(builder::addEnumConstant); builder.addFields(fieldSpecs).addMethods(methodSpecs).addTypes(typeSpecs); originatingElements.forEach(builder::addOriginatingElement); return builder.build(); }
public TypeSpec generateService(ProtoFile protoFile, Service service) { ClassName apiName = (ClassName) typeName(service.type()); TypeSpec.Builder typeBuilder = TypeSpec.interfaceBuilder(apiName.simpleName()); typeBuilder.addModifiers(PUBLIC); InterfaceMetaInfo interfaceMetaInfo = InterfaceMetaInfo.readFrom(protoFile, service); typeBuilder.addAnnotations(interfaceMetaInfo.generateAnnotations()); if (!service.documentation().isEmpty()) { typeBuilder.addJavadoc("$L\n", service.documentation()); } for (Rpc rpc : service.rpcs()) { ProtoType requestType = rpc.requestType(); TypeName requestJavaType = typeName(requestType); ProtoType responseType = rpc.responseType(); TypeName responseJavaType = typeName(responseType); MethodSpec.Builder rpcBuilder = MethodSpec.methodBuilder(rpc.name()); MethodMetaInfo methodMetaInfo = MethodMetaInfo.readFrom(rpc); rpcBuilder.addAnnotation(serviceAnnotation(rpc, apiName, interfaceMetaInfo)); rpcBuilder.addAnnotation(methodMetaInfo.generateRaptorMethod()); rpcBuilder.addModifiers(PUBLIC, ABSTRACT); rpcBuilder.returns(responseJavaType); ParameterSpec request = ParameterSpec.builder(requestJavaType, "request").build(); rpcBuilder.addParameter(request); if (!rpc.documentation().isEmpty()) { rpcBuilder.addJavadoc("$L\n", rpc.documentation()); } typeBuilder.addMethod(rpcBuilder.build()); } return typeBuilder.build(); }
/** * Create the definition of the generated class. * * @param generatedAnnotations annotations to add to the generated type, if any * @return type definition */ public TypeSpec typeSpec(List<AnnotationSpec> generatedAnnotations) { return classBuilder(generatedType) .addFields(fields) .addMethod(constructor()) .addMethods(transform(methods(), getMethod)) .addAnnotations(generatedAnnotations) .addModifiers(PUBLIC, FINAL) .addTypes(nestedTypes) .build(); }
private TypeSpec subcomponent( AndroidInjectorDescriptor descriptor, ClassName subcomponentName, ClassName subcomponentBuilderName) { AnnotationSpec.Builder subcomponentAnnotation = AnnotationSpec.builder(Subcomponent.class); for (ClassName module : descriptor.modules()) { subcomponentAnnotation.addMember("modules", CodeBlock.of("$T.class", module)); } return interfaceBuilder(subcomponentName) .addModifiers(PUBLIC) .addAnnotation(subcomponentAnnotation.build()) .addAnnotations(descriptor.scopes()) .addSuperinterface(parameterizedTypeName(AndroidInjector.class, descriptor.injectedType())) .addType(subcomponentBuilder(descriptor, subcomponentBuilderName)) .build(); }
private TypeSpec subcomponent( AndroidInjectorDescriptor descriptor, ClassName subcomponentName, ClassName subcomponentBuilderName) { AnnotationSpec.Builder subcomponentAnnotation = AnnotationSpec.builder(Subcomponent.class); for (ClassName module : descriptor.modules()) { subcomponentAnnotation.addMember("modules", CodeBlock.of("$T.class", module)); } return interfaceBuilder(subcomponentName) .addModifiers(PUBLIC) .addAnnotation(subcomponentAnnotation.build()) .addAnnotations(descriptor.scopes()) .addSuperinterface(parameterizedTypeName(AndroidInjector.class, descriptor.injectedType())) .addType(subcomponentBuilder(descriptor, subcomponentBuilderName)) .build(); }
private TypeSpec generatedTypeFor(final Class<?> type) { return TypeSpec.classBuilder(matcherNameFor(type)) .addModifiers(Modifier.PUBLIC) .superclass(parameterizedTypesafeMatchertype(type)) .addField(innerMatcherField(type)) .addMethod(constructor(type)) .addAnnotations(generatedAnnotations(type)) .addMethods(propertyMethods(type)) .addMethods(typesafeMatcherMethods(type)) .addMethod(factoryMethod(type)).build(); }
public void addToTypeSpec(TypeSpec.Builder typeSpec) { for (JavadocSpec javadocSpec : javadocSpecs) { typeSpec.addJavadoc(javadocSpec.format, javadocSpec.args); } typeSpec.addAnnotations(annotationSpecs); typeSpec.addFields(fieldSpecs); typeSpec.addMethods(methodSpecs); typeSpec.addTypes(typeSpecs); typeSpec.addSuperinterfaces(superInterfaces); }