public static MethodSpec.Builder overriding(ExecutableElement method) { return MethodSpec.methodBuilder(method.getSimpleName().toString()) .addAnnotation(Override.class) .addModifiers(method.getModifiers().stream().filter(modifier -> modifier != Modifier.ABSTRACT).collect(Collectors.toList())) .returns(TypeName.get(method.getReturnType())) .varargs(method.isVarArgs()) .addExceptions(method.getThrownTypes().stream().map(TypeName::get).collect(Collectors.toList())) .addTypeVariables(method.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList())) .addParameters(method.getParameters().stream().map(element -> ParameterSpec.get(element).toBuilder() .addAnnotations(element.getAnnotationMirrors().stream().map(AnnotationSpec::get).collect(Collectors.toList())).build()).collect(Collectors.toList())); }
private static boolean hasMatchingField( MethodParamModel param, ImmutableList<FieldModel> fields) { for (FieldModel field : fields) { if (param.getName().equals(field.field.name) && (param.getTypeName().box().equals(field.field.type.box()) || isFromEventTypeSpecifiedInAnnotation(param, field.field.type))) { return true; } } return false; }
static boolean requiresCast(TypeName type) { return !VIEW_TYPE.equals(type.toString()); }
@NonNull private String getDefault(@NonNull TypeName type) { if (type.isPrimitive()) { if (type.equals(TypeName.BOOLEAN)) { return "false"; } else if (type.equals(TypeName.BYTE)) { return "0"; } else if (type.equals(TypeName.SHORT)) { return "0"; } else if (type.equals(TypeName.INT)) { return "0"; } else if (type.equals(TypeName.LONG)) { return "0L"; } else if (type.equals(TypeName.CHAR)) { return "\u0000"; } else if (type.equals(TypeName.FLOAT)) { return "0.0f"; } else if (type.equals(TypeName.DOUBLE)) { return "0.0d"; } } return "null"; }
ClassName.get(Map.class), ParameterizedTypeName.get(ClassName.get(Class.class), WildcardTypeName.subtypeOf(Object.class)), TypeName.get(String[].class)); ParameterSpec mapParameterSpec = ParameterSpec.builder(mapTypeName, "map").build(); MethodSpec.Builder methodHandle = MethodSpec.methodBuilder(METHOD_HANDLE) .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addParameter(mapParameterSpec); boolean hasInterceptor = false; // flag for (TypeElement element : elements) { methodHandle.addStatement("map.put($T.class, new String[]{$L})", ClassName.get(element), sb.substring(0, sb.lastIndexOf(","))); } else if (interceptors.length == 1) { hasInterceptor = true; .addSuperinterface(ClassName.get(interfaceType)) .addModifiers(Modifier.PUBLIC) .addMethod(methodHandle.build()) .addJavadoc(CLASS_JAVA_DOC) .build();
TypeName controllerType = TypeName.get(type.asType()); FieldSpec hostField = FieldSpec.builder(controllerType, "mHost", Modifier.PRIVATE).build(); FieldSpec mappingField = FieldSpec.builder(mMappings, "mMappingMap", Modifier.PRIVATE).build(); rootCode.beginControlFlow("\n").addStatement("$T mapping = new $T()", mMapping, mMapping); addMapping(rootCode, mapping); rootCode.addStatement("mapping = new $T(mapping)", mMappingUnmodifiable); mapping.isRest()).addStatement("mMappingMap.put(mapping, handler)").endControlFlow(); MethodSpec rootMethod = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addCode(rootCode.build()) .build(); MethodSpec mappingMethod = MethodSpec.methodBuilder("getMappingMap") .addAnnotation(Override.class) .addModifiers(Modifier.PROTECTED) .build(); MethodSpec hostMethod = MethodSpec.methodBuilder("getHost") .addAnnotation(Override.class) .addModifiers(Modifier.PROTECTED)
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")); , 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()) { methodBuilder.addParameter(TypeName.get(ep.asType()), ep.getSimpleName().toString()); paramsString += ep.getSimpleName().toString() + ",";
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());
private void createBuilderClass(@NonNull List<Element> elements) throws IOException { final TypeSpec.Builder classBuilder = TypeSpec.classBuilder(builderName) .addModifiers(Modifier.FINAL); final TypeName baseAnnotation = TypeName.get(this.baseAnnotation.asType()); Strings.addClassJavadoc(classBuilder, baseAnnotation); final MethodSpec.Builder constructor = MethodSpec.constructorBuilder() .addParameter(ParameterSpec.builder(Types.CONTEXT, PARAM_0).addAnnotation(Types.NON_NULL).build()) .addJavadoc("@param $L object annotated with {@link $T}\n", PARAM_0, baseAnnotation) .addStatement("final $1T $2L = $3L.getClass().getAnnotation($1T.class)", baseAnnotation, VAR_ANNOTATION, PARAM_0); if (!configuration.isPlugin()) { classBuilder.addModifiers(Modifier.PUBLIC) .addSuperinterface(ConfigurationBuilder.class); constructor.addModifiers(Modifier.PUBLIC); } else { classBuilder.addSuperinterface(ClassName.get(PACKAGE, builderVisibleName));
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))) { .addSuperinterface(ParameterizedTypeName.get( ClassName.get(Callable.class), nativeReturnTypeName)) .addMethod(MethodSpec.methodBuilder("call") .addAnnotation(Override.class) .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class) methodBuilder.addStatement("return new $T(\n$L)", ClassName.get( "org.web3j.tuples.generated", "Tuple" + returnTypes.size()),
static Builder newBuilder(TypeElement enclosingElement) { TypeMirror typeMirror = enclosingElement.asType(); boolean isView = isSubtypeOfType(typeMirror, VIEW_TYPE); boolean isActivity = isSubtypeOfType(typeMirror, ACTIVITY_TYPE); boolean isDialog = isSubtypeOfType(typeMirror, DIALOG_TYPE); TypeName targetType = TypeName.get(typeMirror); if (targetType instanceof ParameterizedTypeName) { targetType = ((ParameterizedTypeName) targetType).rawType; } String packageName = getPackage(enclosingElement).getQualifiedName().toString(); String className = enclosingElement.getQualifiedName().toString().substring( packageName.length() + 1).replace('.', '$'); ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding"); boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL); return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog); }
@Override protected TypeName defaultAction(TypeMirror typeMirror, Void v) { return TypeName.get(typeMirror); } }, null);
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); resetCode.addStatement("$L.release(_eventState)", poolName); if (eventDeclaration.returnType.equals(TypeName.VOID)) { eventDispatcherMethod.addStatement("_lifecycle.dispatchOnEvent(_eventHandler, _eventState)"); eventDispatcherMethod.addCode(resetCode.build()); } else { eventDispatcherMethod
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); .constructorBuilder() .addModifiers(constructor.getModifiers()) .addParameters(ProcessorUtils.extractParameters(constructor)) .addStatement("super($L)", constructor.getParameters()); typeBuilder.addMethod(constructorBuilder.build()); .methodBuilder(DELEGATE_METHOD) .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT) .returns(TypeName.get(typeMirror)); typeBuilder.addMethod(delegateMethod.build()); .overriding(methodElement) .addStatement(callFormat, callArgs); if (typeToExtend.isInterface()) {
private void generateDefaultTraversal(final Context ctx) throws IOException { final TypeSpec.Builder defaultTraversalClass = TypeSpec.classBuilder(ctx.defaultTraversalClazz) .addModifiers(Modifier.PUBLIC) .addTypeVariables(Arrays.asList(TypeVariableName.get("S"), TypeVariableName.get("E"))) .superclass(TypeName.get(elementUtils.getTypeElement(DefaultTraversal.class.getCanonicalName()).asType())) .addSuperinterface(ParameterizedTypeName.get(ctx.traversalClassName, TypeVariableName.get("S"), TypeVariableName.get("E"))); defaultTraversalClass.addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addStatement("super()") .build()); defaultTraversalClass.addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(Graph.class, "graph") .addStatement("super($N)", "graph") .build()); defaultTraversalClass.addMethod(MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(ctx.traversalSourceClassName, "traversalSource")
private static MethodSpec generateStaticTriggerMethodWithKey( String componentName, ClassName contextClassName, SpecMethodModel<EventMethod, EventDeclarationModel> eventMethodModel) { MethodSpec.Builder triggerMethod = MethodSpec.methodBuilder(eventMethodModel.name.toString()) .addModifiers(Modifier.PUBLIC, Modifier.STATIC); String methodId = componentName + ComponentBodyGenerator.getEventTriggerInstanceName(eventMethodModel.name); triggerMethod .addParameter(contextClassName, "c") .addParameter(ClassNames.STRING, "key") .addStatement("$T methodId = $L", TypeName.INT, methodId.hashCode()) .addStatement("$T trigger = getEventTrigger(c, methodId, key)", ClassNames.EVENT_TRIGGER); EventDeclarationModel eventDeclaration = eventMethodModel.typeModel; triggerMethod.beginControlFlow("if (trigger == null)"); triggerMethod.addStatement( (eventDeclaration.returnType == null || eventDeclaration.returnType.equals(TypeName.VOID)) ? "return" : "return null"); triggerMethod.endControlFlow(); return generateCommonStaticTriggerMethodCode(contextClassName, eventMethodModel, triggerMethod); }
@Nullable @Override public String apply(@Nullable FieldSpec fieldSpec) { if ( fieldSpec.type.isPrimitive() || fieldSpec.type.equals(ClassName.get(String.class))) { return CodeBlock.builder().add("$S + $T.toString(this.$L)", fieldSpec.name + " = ", Objects.class, fieldSpec.name).build().toString(); } else { return CodeBlock.builder().add("$S + $T.toString(this.$L) + \"]\"", fieldSpec.name + " = [", Objects.class, fieldSpec.name).build().toString(); } } }).join(Joiner.on(" + \", \" + "));
final TypeName cachedValueType = onCalculateCachedValueMethod.returnType; MethodSpec.Builder methodSpec = MethodSpec.methodBuilder(getCachedValueGetterName(cachedValueName)) .addModifiers(Modifier.PRIVATE) .returns(cachedValueType) .addStatement("$T c = getScopedContext()", specModel.getContextClass()); codeBlock.add( "$L,", ComponentBodyGenerator.getImplAccessor( .addStatement( "$T $L = ($T) c.getCachedValue(inputs)", cachedValueType.box(), cachedValueName, cachedValueType.box()) .beginControlFlow("if ($L == null)", cachedValueName); final CodeBlock.Builder delegation = CodeBlock.builder(); delegation .add(
private static MethodSpec generateCommonStaticTriggerMethodCode( ClassName contextClassName, SpecMethodModel<EventMethod, EventDeclarationModel> eventMethodModel, MethodSpec.Builder eventTriggerMethod) { EventDeclarationModel eventDeclaration = eventMethodModel.typeModel; eventTriggerMethod.addStatement( "$T _eventState = new $T()", eventDeclaration.name, // need to make these into types eventDeclaration.name); final CodeBlock.Builder paramsBlock = CodeBlock.builder(); paramsBlock.add("new Object[] {\n"); paramsBlock.indent(); addParametersToStaticTriggerMethods(contextClassName, eventMethodModel, eventTriggerMethod); addTriggerParams(contextClassName, eventMethodModel, eventTriggerMethod, paramsBlock); paramsBlock.unindent(); paramsBlock.add("}"); if (eventDeclaration.returnType == null || eventDeclaration.returnType.equals(TypeName.VOID)) { eventTriggerMethod.addStatement( "trigger.dispatchOnTrigger(_eventState, $L)", paramsBlock.build()); } else { eventTriggerMethod .addStatement( "return ($L) trigger.dispatchOnTrigger(_eventState, $L)", eventDeclaration.returnType, paramsBlock.build()) .returns(eventDeclaration.returnType); } return eventTriggerMethod.build(); }
private static boolean isFromEventTypeSpecifiedInAnnotation( MethodParamModel methodParamModel, TypeName eventFieldType) { FromEvent fromEvent = (FromEvent) MethodParamModelUtils.getAnnotation(methodParamModel, FromEvent.class); TypeName baseClassType; try { baseClassType = ClassName.get(fromEvent.baseClass()); } catch (MirroredTypeException mte) { baseClassType = ClassName.get(mte.getTypeMirror()); } return baseClassType.equals(eventFieldType); } }