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()); }
static MethodSpec generateStateContainerGetter(TypeName stateContainerClassName) { return MethodSpec.methodBuilder("getStateContainer") .addModifiers(Modifier.PROTECTED) .addAnnotation(Override.class) .returns(stateContainerClassName) .addStatement("return $N", STATE_CONTAINER_FIELD_NAME) .build(); }
private void writePropagatingErrorCase(MethodSpec.Builder methodBuilder) { methodBuilder .beginControlFlow("case $L:", INTERNAL_ON_ERROR_HANDLER_NAME.toString().hashCode()) .addStatement( "dispatchErrorEvent(($L) eventHandler.params[0], ($L) eventState)", mContextClass, ClassNames.ERROR_EVENT) .addStatement("return null") .endControlFlow(); }
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 void onDraw(TypeSpec.Builder typeBuilder) { MethodSpec methodSpec = MethodSpec.methodBuilder("onDraw") .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addParameter(ClassName.get("android.graphics", "Canvas"), "canvas") .addStatement("super.onDraw(canvas)") .addStatement("mBadgeViewHelper.drawBadge(canvas)") .build(); typeBuilder.addMethod(methodSpec); }
MethodSpec buildDefaultEventFlowableFunction( String responseClassName, String functionName) { String generatedFunctionName = Strings.lowercaseFirstLetter(functionName) + "EventFlowable"; ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(ClassName.get(Flowable.class), ClassName.get("", responseClassName)); MethodSpec.Builder flowableMethodBuilder = MethodSpec.methodBuilder(generatedFunctionName) .addModifiers(Modifier.PUBLIC) .addParameter(DefaultBlockParameter.class, START_BLOCK) .addParameter(DefaultBlockParameter.class, END_BLOCK) .returns(parameterizedTypeName); flowableMethodBuilder.addStatement("$1T filter = new $1T($2L, $3L, " + "getContractAddress())", EthFilter.class, START_BLOCK, END_BLOCK) .addStatement("filter.addSingleTopic($T.encode(" + buildEventDefinitionName(functionName) + "))", EventEncoder.class) .addStatement("return " + generatedFunctionName + "(filter)"); return flowableMethodBuilder .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(); }
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) .addParameter(Log.class, "log") .returns(ClassName.get("", responseClassName)) .addStatement("$T eventValues = extractEventParametersWithLog(" + buildEventDefinitionName(functionName) + ", log)", Contract.EventValuesWithLog.class) .addStatement("$1T typedResponse = new $1T()", ClassName.get("", responseClassName)) .addCode(buildTypedResponse("typedResponse", indexedParameters, nonIndexedParameters, true)) .addStatement("return typedResponse") .build()) .build(); .addStatement("return web3j.ethLogFlowable(filter).map($L)", converter); .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(); }
MethodSpec.methodBuilder("consumeTransitions") .addModifiers(Modifier.PUBLIC) .addAnnotation(Override.class) .returns( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box())) .addCode( CodeBlock.builder() .beginControlFlow( .endControlFlow() .build()) .addStatement( "$T<$T> $N", ClassNames.LIST, specModel.getTransitionClass(), transitionsCopyVarName) .beginControlFlow( "synchronized ($L)", GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME) .addStatement( "$N = new $T<>($N)", transitionsCopyVarName, ClassNames.ARRAY_LIST, GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME) .addStatement("$N.clear()", GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME) .endControlFlow() .addStatement("return $N", transitionsCopyVarName) .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(); }
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()); } }
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(); .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); eventDispatcherMethod.addStatement( "$T _lifecycle = _eventHandler.mHasEventDispatcher.getEventDispatcher()", ClassNames.EVENT_DISPATCHER); eventDispatcherMethod.addStatement("_lifecycle.dispatchOnEvent(_eventHandler, _eventState)"); eventDispatcherMethod.addCode(resetCode.build()); } else { eventDispatcherMethod .addStatement( "$T result = ($T) _lifecycle.dispatchOnEvent(_eventHandler, _eventState)", eventDeclaration.returnType, eventDeclaration.returnType) .returns(eventDeclaration.returnType); eventDispatcherMethod.addCode(resetCode.build()); eventDispatcherMethod.addStatement("return result");
result.beginControlFlow("if (view != null)"); result.addStatement("$L = $N", fieldName, bindName); MethodSpec.Builder callbackMethod = MethodSpec.methodBuilder(method.name()) .addAnnotation(Override.class) .addModifiers(PUBLIC) .returns(bestGuess(method.returnType())); String[] parameterTypes = method.parameters(); for (int i = 0, count = parameterTypes.length; i < count; i++) { callbackMethod.addParameter(bestGuess(parameterTypes[i]), "p" + i); 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()); result.addStatement("(($T) $N).$L($L)", bestGuess(targetType), bindName, listener.setter(), requiresRemoval ? listenerField : callback.build()); } else { result.addStatement("$N.$L($L)", bindName, listener.setter(), requiresRemoval ? listenerField : callback.build()); result.endControlFlow();
private MethodSpec createBindingConstructorForActivity() { MethodSpec.Builder builder = MethodSpec.constructorBuilder() .addAnnotation(UI_THREAD) .addModifiers(PUBLIC) .addParameter(targetTypeName, "target"); if (constructorNeedsView()) { builder.addStatement("this(target, target.getWindow().getDecorView())"); } else { builder.addStatement("this(target, target)"); } return builder.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)); builder.addParameter(methodParamModel.getTypeName(), methodParamModel.getName()); paramsBlock.add("$L,\n", methodParamModel.getName()); builder.addTypeVariable((TypeVariableName) methodParamModel.getTypeName()); paramsBlock.add("}"); builder.addStatement( "return newEventHandler(c, $L, $L)", eventMethodModel.name.toString().hashCode(), paramsBlock.build()); return builder.build();
public TypeSpec api(Service service) { ClassName apiName = (ClassName) javaGenerator.typeName(service.type()); TypeSpec.Builder typeBuilder = TypeSpec.interfaceBuilder(apiName.simpleName()); typeBuilder.addModifiers(PUBLIC); typeBuilder.addJavadoc("$L\n", service.documentation()); TypeName responseJavaType = javaGenerator.typeName(responseType); MethodSpec.Builder rpcBuilder = MethodSpec.methodBuilder(rpc.name()); rpcBuilder.addModifiers(PUBLIC, ABSTRACT); rpcBuilder.returns(responseJavaType); rpcBuilder.addParameter(requestJavaType, "request"); rpcBuilder.addJavadoc("$L\n", rpc.documentation()); typeBuilder.addMethod(rpcBuilder.build());
StateParamModel stateValue) { final MethodSpec.Builder builder = MethodSpec.methodBuilder( "lazyUpdate" + stateValue.getName().substring(0, 1).toUpperCase(Locale.ROOT) + stateValue.getName().substring(1)) .addModifiers(Modifier.PROTECTED, Modifier.STATIC) .addParameter(specModel.getContextClass(), "c") .addTypeVariables(MethodParamModelUtils.getTypeVariables(stateValue)) .addParameter(stateValue.getTypeName(), LAZY_STATE_UPDATE_VALUE_PARAM, Modifier.FINAL); builder.addStatement( "$T _component = c.get$LScope()", specModel.getComponentClass(), specModel.getComponentClass().simpleName()) .addCode( CodeBlock.builder() .beginControlFlow("if (_component == null)") MethodSpec.methodBuilder(STATE_UPDATE_METHOD_NAME) .addAnnotation(Override.class) .addParameter(specModel.getStateContainerClass(), STATE_CONTAINER_PARAM_NAME) .addModifiers(Modifier.PUBLIC) .addStatement( "$L $L = ($L) $L", ComponentBodyGenerator.getStateContainerClassName(specModel), ComponentBodyGenerator.getStateContainerClassName(specModel), STATE_CONTAINER_PARAM_NAME)
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(); }