String CLASS_NAME = "ApiFactory"; String DATA_ARR_CLASS = "DataArr"; TypeSpec.Builder tb = classBuilder(CLASS_NAME).addModifiers(PUBLIC, FINAL).addJavadoc("@ API工厂 此类由apt自动生成"); try { for (TypeElement element : ElementFilter.typesIn(roundEnv.getElementsAnnotatedWith(ApiFactory.class))) { ExecutableElement executableElement = (ExecutableElement) e; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(e.getSimpleName().toString()) .addJavadoc("@此方法由apt自动生成") .addModifiers(PUBLIC, STATIC); if (TypeName.get(executableElement.getReturnType()).toString().contains(DATA_ARR_CLASS)) {//返回列表数据 methodBuilder.returns(ClassName.get("io.reactivex", "Flowable")); ClassName apiUtil = ClassName.get("com.base.util", "ApiUtil"); ClassName C = ClassName.get("com", "C"); CodeBlock.Builder blockBuilder = CodeBlock.builder(); int len = executableElement.getParameters().size(); for (int i = 0; i < len; i++) { , blockBuilder.build().toString() , ClassName.get("com.base.util.helper", "RxSchedulers")); tb.addMethod(methodBuilder.build()); } else {//返回普通数据 methodBuilder.returns(TypeName.get(executableElement.getReturnType())); String paramsString = ""; for (VariableElement ep : executableElement.getParameters()) {
Id(int value, @Nullable Symbol rSymbol) { this.value = value; if (rSymbol != null) { ClassName className = ClassName.get(rSymbol.packge().getQualifiedName().toString(), R, rSymbol.enclClass().name.toString()); String resourceName = rSymbol.name.toString(); this.code = className.topLevelClassName().equals(ANDROID_R) ? CodeBlock.of("$L.$N", className, resourceName) : CodeBlock.of("$T.$N", className, resourceName); this.qualifed = true; } else { this.code = CodeBlock.of("$L", value); this.qualifed = false; } }
private CodeBlock javadocWithParameters() { CodeBlock.Builder builder = javadoc.toBuilder(); boolean emitTagNewline = true; for (ParameterSpec parameterSpec : parameters) { if (!parameterSpec.javadoc.isEmpty()) { // Emit a new line before @param section only if the method javadoc is present. if (emitTagNewline && !javadoc.isEmpty()) builder.add("\n"); emitTagNewline = false; builder.add("@param $L $L", parameterSpec.name, parameterSpec.javadoc); } } return builder.build(); }
@NonNull @Override public CodeBlock visitArray(@NonNull List<? extends AnnotationValue> values, Void v) { ArrayTypeName arrayTypeName = (ArrayTypeName) type; if (arrayTypeName.componentType instanceof ParameterizedTypeName) { arrayTypeName = ArrayTypeName.of(((ParameterizedTypeName) arrayTypeName.componentType).rawType); } return CodeBlock.of("new $T{$L}", arrayTypeName, values.stream().map(value -> value.accept(this, null)) .reduce((c1, c2) -> CodeBlock.builder().add(c1).add(", ").add(c2).build()).orElseGet(() -> CodeBlock.builder().build())); } }
private void createRegister(Map<String, TypeElement> converterMap) { TypeName typeName = ParameterizedTypeName.get(ClassName.get(Map.class), mString, mConverter); FieldSpec mapField = FieldSpec.builder(typeName, "mMap", Modifier.PRIVATE).build(); CodeBlock.Builder rootCode = CodeBlock.builder().addStatement("this.mMap = new $T<>()", HashMap.class); for (Map.Entry<String, TypeElement> entry : converterMap.entrySet()) { String group = entry.getKey(); TypeElement converter = entry.getValue(); mLog.i(String.format("------ Processing %s ------", converter.getSimpleName())); rootCode.addStatement("this.mMap.put($S, new $T())", group, converter); MethodSpec rootMethod = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addCode(rootCode.build()) .build(); MethodSpec registerMethod = MethodSpec.methodBuilder("onRegister") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addJavadoc(Constants.DOC_EDIT_WARN) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addSuperinterface(mOnRegisterType) .addField(mapField) .addMethod(rootMethod)
SpecMethodModel<EventMethod, EventDeclarationModel> eventMethodModel) { MethodSpec.Builder triggerMethod = MethodSpec.methodBuilder(eventMethodModel.name.toString()).addModifiers(Modifier.STATIC); triggerMethod.addParameter(contextClassName, "c"); triggerMethod.addStatement( "$L component = ($L) c.$L()", componentClass, componentClass, scopeMethodName); CodeBlock.builder().add("\n($T) $L", ClassNames.EVENT_TRIGGER_TARGET, "component"); eventTriggerParams.add(",\n$L", methodParamModel.getName()); continue; eventTriggerParams.add(",\n$L", methodParamModel.getName()); if (eventDeclaration.returnType == null || eventDeclaration.returnType.equals(TypeName.VOID)) { triggerMethod.addStatement( "component.$L($L)", eventMethodModel.name, eventTriggerParams.build());
@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(); }
final CodeBlock.Builder always = CodeBlock.builder(); final CodeBlock.Builder whenAnnotationPresent = CodeBlock.builder(); final CodeBlock.Builder whenAnnotationMissing = CodeBlock.builder(); ClassName builder = ClassName.get(PACKAGE, builderName); elements.stream().filter(BuilderElement.class::isInstance).map(BuilderElement.class::cast).forEach(m -> m.addToBuilder(classBuilder, builder, always, whenAnnotationPresent, whenAnnotationMissing)); constructor.addCode(always.build()) .beginControlFlow("if ($L)", Strings.FIELD_ENABLED) .addCode(whenAnnotationPresent.build()) .nextControlFlow("else") .addCode(whenAnnotationMissing.build()) .endControlFlow(); classBuilder.addMethod(constructor.build()); final BuildMethodCreator build = new BuildMethodCreator(Types.getOnlyMethod(processingEnv, ConfigurationBuilder.class.getName()), ClassName.get(PACKAGE, configName)); elements.stream().filter(ValidatedElement.class::isInstance).map(ValidatedElement.class::cast).forEach(element -> element.addToBuildMethod(build)); classBuilder.addMethod(build.build());
if (addresses != null) { ClassName stringType = ClassName.get(String.class); ClassName mapType = ClassName.get(HashMap.class); TypeName mapStringString = ParameterizedTypeName.get(mapType, stringType, stringType); FieldSpec addressesStaticField = FieldSpec Modifier.PROTECTED, Modifier.STATIC, Modifier.FINAL) .build(); classBuilder.addField(addressesStaticField); final CodeBlock.Builder staticInit = CodeBlock.builder(); staticInit.addStatement("_addresses = new HashMap<String, String>()"); addresses.forEach((k, v) -> staticInit.addStatement(String.format("_addresses.put(\"%1s\", \"%2s\")", k, v)) ); classBuilder.addStaticBlock(staticInit.build()); .builder() classBuilder.addMethod(getAddress); .methodBuilder("getPreviouslyDeployedAddress") .builder()
private void emitGetTargetScope(TypeSpec.Builder builder) { CodeBlock.Builder getParentScopeCodeBlockBuilder = getParentScopeCodeBlockBuilder(); MethodSpec.Builder getScopeBuilder = MethodSpec.methodBuilder("getTargetScope") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addParameter(ClassName.get(Scope.class), "scope") .returns(ClassName.get(Scope.class)) .addStatement("return scope$L", getParentScopeCodeBlockBuilder.build().toString()); builder.addMethod(getScopeBuilder.build()); }
@Override public void process(RoundEnvironment roundEnv, AnnotationProcessor mAbstractProcessor) { String CLASS_NAME = "InstanceFactory"; TypeSpec.Builder tb = classBuilder(CLASS_NAME).addModifiers(PUBLIC, FINAL).addJavadoc("@ 实例化工厂 此类由apt自动生成"); MethodSpec.Builder methodBuilder1 = MethodSpec.methodBuilder("create").addAnnotation(MemoryCache.class) .addJavadoc("@此方法由apt自动生成") .returns(Object.class).addModifiers(PUBLIC, STATIC).addException(IllegalAccessException.class).addException(InstantiationException.class) .addParameter(Class.class, "mClass"); CodeBlock.Builder blockBuilder = CodeBlock.builder(); blockBuilder.beginControlFlow(" switch (mClass.getSimpleName())");//括号开始 try { for (TypeElement element : ElementFilter.typesIn(roundEnv.getElementsAnnotatedWith(InstanceFactory.class))) { mAbstractProcessor.mMessager.printMessage(Diagnostic.Kind.NOTE, "正在处理: " + element.toString()); if (!Utils.isValidClass(mAbstractProcessor.mMessager, element)) return; ClassName currentType = ClassName.get(element); if (mList.contains(currentType)) continue; mList.add(currentType); blockBuilder.addStatement("case $S: return new $T()", currentType.simpleName(), currentType);//初始化Presenter blockBuilder.addStatement("default: return mClass.newInstance()"); blockBuilder.endControlFlow(); methodBuilder1.addCode(blockBuilder.build()); tb.addMethod(methodBuilder1.build()); JavaFile javaFile = JavaFile.builder(Utils.PackageName, tb.build()).build();// 生成源代码
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>() {}))", if (nativeReturnTypeName.equals(ClassName.get(List.class))) { CodeBlock.Builder callCode = CodeBlock.builder(); callCode.addStatement( "$T result = " + "($T) executeCallSingleValueReturn(function, $T.class)", listType, listType, nativeReturnTypeName); callCode.addStatement("return convertToNative(result)"); methodBuilder.addStatement("return new $T(\n$L)", ClassName.get( "org.web3j.tuples.generated", "Tuple" + returnTypes.size()),
private static MethodSpec generateRecordRenderDataMethod(SpecModel specModel) { final TypeName renderInfoTypeName = ClassName.bestGuess(getRenderDataImplClassName(specModel)); final CodeBlock code = CodeBlock.builder() .add("$T $L = $L != null ?\n", renderInfoTypeName, "renderInfo", "toRecycle") .indent() .add("($T) $L :\n", renderInfoTypeName, "toRecycle") .add("new $T();\n", renderInfoTypeName) .unindent() .addStatement("$L.record(this)", "renderInfo") .addStatement("return $L", "renderInfo") .build(); return MethodSpec.methodBuilder("recordRenderData") .addAnnotation(Override.class) .addModifiers(Modifier.PROTECTED) .addParameter(ClassNames.RENDER_DATA, "toRecycle") .returns(ClassNames.RENDER_DATA) .addCode(code) .build(); }
CodeBlock.Builder tupleConstructor = CodeBlock.builder(); tupleConstructor.addStatement( "$T results = executeCallMultipleValueReturn(function)", ParameterizedTypeName.get(List.class, Type.class)) .add("return new $T(", tupleType) .add("$>$>"); ClassName classList = ClassName.get(List.class); ParameterizedTypeName oldContainer = (ParameterizedTypeName)param; ParameterizedTypeName newContainer = (ParameterizedTypeName)convertTo; if (newContainer.rawType.compareTo(classList) == 0 && newContainer.typeArguments.size() == 1) { convertTo = ParameterizedTypeName.get(classList, .addSuperinterface(ParameterizedTypeName.get( ClassName.get(Callable.class), tupleType)) .addMethod(MethodSpec.methodBuilder("call") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addException(Exception.class) .returns(tupleType) .addCode(tupleConstructor.build()) .build()) .build(); methodBuilder.addStatement(
static TypeSpecDataHolder generateEventDispatcher(EventDeclarationModel eventDeclaration) { final TypeSpecDataHolder.Builder typeSpecDataHolder = TypeSpecDataHolder.newBuilder(); final String poolName = "s" + eventDeclaration.name.simpleName() + "Pool"; final TypeName poolType = ParameterizedTypeName.get(ClassNames.SYNCHRONIZED_POOL, eventDeclaration.name); MethodSpec.methodBuilder("dispatch" + eventDeclaration.name.simpleName()) .addModifiers(Modifier.STATIC) .addParameter(ClassNames.EVENT_HANDLER, "_eventHandler"); .addStatement("$T _eventState = $L.acquire()", eventDeclaration.name, poolName) .beginControlFlow("if (_eventState == null)") .addStatement("_eventState = new $T()", eventDeclaration.name) .endControlFlow(); final CodeBlock.Builder resetCode = CodeBlock.builder(); for (FieldModel fieldModel : eventDeclaration.fields) { if (fieldModel.field.modifiers.contains(Modifier.FINAL)) { .addParameter(fieldModel.field.type, fieldModel.field.name) .addStatement("_eventState.$L = $L", fieldModel.field.name, fieldModel.field.name); if (!fieldModel.field.type.isPrimitive()) { resetCode.addStatement("_eventState.$L = null", fieldModel.field.name); ClassNames.EVENT_DISPATCHER);
private void generateDeepLinkDelegate(String packageName, List<TypeElement> loaderClasses) throws IOException { CodeBlock.Builder loadersInitializer = CodeBlock.builder() .add("super($T.asList(\n", ClassName.get(Arrays.class)) .indent(); int totalElements = loaderClasses.size(); for (int i = 0; i < totalElements; i++) { loadersInitializer.add("$L$L", decapitalize(moduleNameToLoaderName(loaderClasses.get(i))), i < totalElements - 1 ? ",\n" : "\n"); MethodSpec constructor = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameters(FluentIterable.from(loaderClasses).transform( new Function<TypeElement, ParameterSpec>() { @Override public ParameterSpec apply(TypeElement typeElement) { .addCode(loadersInitializer.unindent().add("));\n").build()) .build(); .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .superclass(CLASS_BASE_DEEP_LINK_DELEGATE) .addMethod(constructor) .build();
static TypeSpecDataHolder generateGetEventHandlerMethod( SpecModel specModel, EventDeclarationModel eventDeclaration) { final String scopeMethodName = specModel.getScopeMethodName(); return TypeSpecDataHolder.newBuilder() .addMethod( MethodSpec.methodBuilder("get" + eventDeclaration.name.simpleName() + "Handler") .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .returns(ClassNames.EVENT_HANDLER) .addParameter(specModel.getContextClass(), "context") .addCode( CodeBlock.builder() .beginControlFlow("if (context.$L() == null)", scopeMethodName) .addStatement("return null") .endControlFlow() .build()) .addStatement( "return (($L) context.$L()).$L", specModel.getComponentName(), scopeMethodName, ComponentBodyGenerator.getEventHandlerInstanceName(eventDeclaration.name)) .build()) .build(); }
static MethodSpec generateEventHandlerFactory( SpecMethodModel<EventMethod, EventDeclarationModel> eventMethodModel, TypeName paramClass) { final MethodSpec.Builder builder = MethodSpec.methodBuilder(eventMethodModel.name.toString()) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addTypeVariables(eventMethodModel.typeVariables) .addParameter(paramClass, "c") .returns( ParameterizedTypeName.get( ClassNames.EVENT_HANDLER, eventMethodModel.typeModel.name)); final CodeBlock.Builder paramsBlock = CodeBlock.builder(); paramsBlock.add("new Object[] {\n"); paramsBlock.indent(); paramsBlock.add("c,\n");
result.beginControlFlow("if (view != null)"); bindName = "view"; result.addStatement("$L = $N", fieldName, bindName); .superclass(ClassName.bestGuess(listener.type())); MethodSpec.Builder callbackMethod = MethodSpec.methodBuilder(method.name()) .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(bestGuess(method.returnType())); CodeBlock.Builder builder = CodeBlock.builder(); if (hasReturnType) { builder.add("return "); callbackMethod.addCode(builder.build()); callback.addMethod(callbackMethod.build()); if (requiresRemoval) { TypeName listenerClassName = bestGuess(listener.type()); listenerField = fieldName + ((ClassName) listenerClassName).simpleName(); result.addStatement("$L = $L", listenerField, callback.build());