private void emitNextStateGetter(TypeSpec.Builder intentBuilderTypeBuilder) { final TypeName initialStateGeneric = getInitialStateGeneric(false); MethodSpec.Builder initialStateGetterForSubBuilder = MethodSpec.methodBuilder(NEXT_STATE_METHOD) .addModifiers(Modifier.PUBLIC) .addModifiers(Modifier.STATIC) .addTypeVariable((TypeVariableName) initialStateGeneric) .addParameter(Bundler.class, "bundler") .addParameter(initialStateGeneric, "allSetState") .returns(getInitialStateType(initialStateGeneric)); if (target.hasRequiredFields) { initialStateGetterForSubBuilder.addStatement( "return new $L<>(bundler, allSetState)", REQUIRED_SEQUENCE_CLASS); intentBuilderTypeBuilder.addMethod(initialStateGetterForSubBuilder.build()); return; } if (target.parentPackage != null) { final String parentIntentBuilderClass = target.parentClass + BUNDLE_BUILDER_SUFFIX; initialStateGetterForSubBuilder.addStatement( "return $T.getNextState(bundler, allSetState)", get(target.parentPackage, parentIntentBuilderClass)); intentBuilderTypeBuilder.addMethod(initialStateGetterForSubBuilder.build()); return; } initialStateGetterForSubBuilder.addStatement("return allSetState"); intentBuilderTypeBuilder.addMethod(initialStateGetterForSubBuilder.build()); }
methodBuilder.addTypeVariable(TypeVariableName.get(var));
builder.addTypeVariable((TypeVariableName) methodParamModel.getTypeName());
private static void addCheckNotNullMethod( TypeSpec.Builder factory, FactoryDescriptor descriptor) { if (shouldGenerateCheckNotNull(descriptor)) { TypeVariableName typeVariable = TypeVariableName.get("T"); factory.addMethod( methodBuilder("checkNotNull") .addModifiers(PRIVATE, STATIC) .addTypeVariable(typeVariable) .returns(typeVariable) .addParameter(typeVariable, "reference") .addParameter(TypeName.INT, "argumentIndex") .beginControlFlow("if (reference == null)") .addStatement( "throw new $T($S + argumentIndex)", NullPointerException.class, "@AutoFactory method argument is null but is not marked @Nullable. Argument " + "index: ") .endControlFlow() .addStatement("return reference") .build()); } }
private DeriveResult<DerivedCodeSpec> visitorDispatchImpl(AlgebraicDataType adt, DeclaredType visitorType, List<DataConstructor> constructors) { NameAllocator nameAllocator = nameAllocator(adt, constructors); MethodSpec cataMethod = MethodSpec.methodBuilder("cata") .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addTypeVariables(adt.typeConstructor().typeVariables().stream().map(TypeVariableName::get).collect(toList())) .addTypeVariable(TypeVariableName.get(adt.matchMethod().returnTypeVariable())) .returns( TypeName.get(utils.types().getDeclaredType(utils.function1Model(adt.deriveConfig().flavour()).samClass(), adt.typeConstructor().declaredType(), adt.matchMethod().returnTypeVariable()))) .addParameters(constructors.stream() .map(dc -> ParameterSpec.builder(cataMapperTypeName(adt, dc), MapperDerivator.mapperFieldName(dc)).build()) .collect(toList())) .addParameter( ParameterSpec.builder(TypeName.get(delayType(adt)), nameAllocator.newName("delay", "delay")).build()) .addStatement("return cata(new $L<>($L), $L)", lambdaVisitorClassName(visitorType), constructors.stream().map(MapperDerivator::mapperFieldName).collect( Collectors.joining(", ")), nameAllocator.get("delay")) .build(); return result(methodSpec(cataMethod).append(cataVisitor(adt, visitorType, constructors))); }
private void addLetComp(TypeSpec.Builder builder, TypeName generatedQualifiedClassName) { ParameterizedTypeName supplierName = ParameterizedTypeName.get(ClassName.get(Supplier.class), TypeVariableName.get("R")); ParameterizedTypeName anyName = ParameterizedTypeName.get(ClassName.get(AnyVal.class), TypeVariableName.get("R")); CodeBlock.Builder codeBuilder = CodeBlock.builder() .addStatement("delegate.letComp(any, supplier)") .addStatement("return this") ; MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("letComp") .addModifiers(Modifier.PUBLIC) .returns(generatedQualifiedClassName) .addTypeVariable(TypeVariableName.get("R")) .addParameter(ParameterSpec.builder(anyName, "any").build()) .addParameter(ParameterSpec.builder(supplierName, "supplier").build()) .addCode(codeBuilder.build()) ; builder.addMethod(methodBuilder.build()); }
private MethodSpec constructMethod(final Element element, final ClassName returnClazz, final String parent, final Modifier... modifiers) { final ExecutableElement templateMethod = (ExecutableElement) element; final String methodName = templateMethod.getSimpleName().toString(); final TypeName returnType = getReturnTypeDefinition(returnClazz, templateMethod); final MethodSpec.Builder methodToAdd = MethodSpec.methodBuilder(methodName) .addModifiers(modifiers) .addAnnotation(Override.class) .addExceptions(templateMethod.getThrownTypes().stream().map(TypeName::get).collect(Collectors.toList())) .returns(returnType); templateMethod.getTypeParameters().forEach(tp -> methodToAdd.addTypeVariable(TypeVariableName.get(tp))); final String parentCall = parent.isEmpty() ? "" : parent + "."; final String body = "return ($T) " + parentCall + "super.$L("; addMethodBody(methodToAdd, templateMethod, body, ")", returnClazz, methodName); return methodToAdd.build(); }
@Override public MethodSpec.Builder generate(String name, AnnotatedPresenter ap, TypeName returns) { List<ClassName> bounds = new ArrayList<>(2); bounds.add(ap.getViewInterface()); if (ViewType.VIEW.equals(ap.getViewType()) || ViewType.DAGGER_VIEW.equals(ap.getViewType())) { bounds.add(SlickProcessor.ClASS_NAME_ON_DESTROY_LISTENER); } final TypeVariableName typeVariableName = TypeVariableName.get("T", "bind".equals(name) ? ap.getView() : ap.getViewType().className()).withBounds(bounds); return MethodSpec.methodBuilder(name) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .addTypeVariable(typeVariableName) .addParameter(typeVariableName, ap.getViewVarName()) .addParameters(addExtraParameters(ap)) .returns(returns); }
private MethodSpec setterCreator() { TypeVariableName t = TypeVariableName.get("T"); return MethodSpec.methodBuilder("setter") .addTypeVariable(t) .addModifiers(Modifier.PRIVATE, Modifier.STATIC) .addParameter(ParameterizedTypeName.get(ClassName.get(BiConsumer.class), builderClassName(), t), "s") .returns(ParameterizedTypeName.get(ClassName.get(BiConsumer.class), ClassName.get(Object.class), t)) .addStatement("return (obj, val) -> s.accept(($T) obj, val)", builderClassName()) .build(); }
private MethodSpec setterCreator() { TypeVariableName t = TypeVariableName.get("T"); return MethodSpec.methodBuilder("setter") .addTypeVariable(t) .addModifiers(Modifier.PRIVATE, Modifier.STATIC) .addParameter(ParameterizedTypeName.get(ClassName.get(BiConsumer.class), builderClassName(), t), "s") .returns(ParameterizedTypeName.get(ClassName.get(BiConsumer.class), ClassName.get(Object.class), t)) .addStatement("return (obj, val) -> s.accept(($T) obj, val)", builderClassName()) .build(); }
private MethodSpec getterCreator() { TypeVariableName t = TypeVariableName.get("T"); return MethodSpec.methodBuilder("getter") .addTypeVariable(t) .addModifiers(Modifier.PRIVATE, Modifier.STATIC) .addParameter(ParameterizedTypeName.get(ClassName.get(Function.class), className(), t), "g") .returns(ParameterizedTypeName.get(ClassName.get(Function.class), ClassName.get(Object.class), t)) .addStatement("return obj -> g.apply(($T) obj)", className()) .build(); }
private MethodSpec getterCreator() { TypeVariableName t = TypeVariableName.get("T"); return MethodSpec.methodBuilder("getter") .addTypeVariable(t) .addModifiers(Modifier.PRIVATE, Modifier.STATIC) .addParameter(ParameterizedTypeName.get(ClassName.get(Function.class), className(), t), "g") .returns(ParameterizedTypeName.get(ClassName.get(Function.class), ClassName.get(Object.class), t)) .addStatement("return obj -> g.apply(($T) obj)", className()) .build(); }
private static void streamingMethod(MethodSpec.Builder methodBuilder, OperationModel opModel, TypeName responseType) { if (opModel.hasStreamingInput()) { methodBuilder.addParameter(ClassName.get(RequestBody.class), "requestBody"); } if (opModel.hasStreamingOutput()) { methodBuilder.addTypeVariable(STREAMING_TYPE_VARIABLE); ParameterizedTypeName streamingResponseHandlerType = ParameterizedTypeName .get(ClassName.get(ResponseTransformer.class), responseType, STREAMING_TYPE_VARIABLE); methodBuilder.addParameter(streamingResponseHandlerType, "responseTransformer"); } }
private static void streamingMethod(MethodSpec.Builder methodBuilder, OperationModel opModel, TypeName responseType) { if (opModel.hasStreamingInput()) { methodBuilder.addParameter(ClassName.get(RequestBody.class), "requestBody"); } if (opModel.hasStreamingOutput()) { methodBuilder.addTypeVariable(STREAMING_TYPE_VARIABLE); ParameterizedTypeName streamingResponseHandlerType = ParameterizedTypeName .get(ClassName.get(ResponseTransformer.class), responseType, STREAMING_TYPE_VARIABLE); methodBuilder.addParameter(streamingResponseHandlerType, "responseTransformer"); } }
.addTypeVariable(TypeVariableName.get("A")) .addStatement("return new $N<>()", ctx.defaultTraversalClazz) .returns(ParameterizedTypeName.get(ctx.traversalClassName, TypeVariableName.get("A"), TypeVariableName.get("A"))) Stream.of(methodAnnotation.get().methodTypeParameters()).map(TypeVariableName::get).forEach(methodToAdd::addTypeVariable); else { templateMethod.getTypeParameters().forEach(tp -> methodToAdd.addTypeVariable(TypeVariableName.get(tp))); returnTypeArguments.stream().filter(rtm -> rtm instanceof TypeVariable).forEach(rtm -> { if (((TypeVariable) rtm).asElement().getSimpleName().contentEquals("S")) methodToAdd.addTypeVariable(TypeVariableName.get(((TypeVariable) rtm).asElement().getSimpleName().toString())); }); .returns(returnType); templateMethod.getTypeParameters().forEach(tp -> methodToAdd.addTypeVariable(TypeVariableName.get(tp)));
private void emitGetFromThisRegistryMethod(TypeSpec.Builder classBuilder) { MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(GET_FROM_THIS_REGISTRY_METHOD_NAME) .addTypeVariable(typeVariable) .addModifiers(Modifier.PRIVATE) .addParameter(clazzArgType, "clazz") .returns(factoryType); if (classNameList.isEmpty()) { methodBuilder.addStatement("return null"); classBuilder.addMethod(methodBuilder.build()); return; } methodBuilder.addStatement("$T index = $L.get(clazz.getName())", Integer.class, MAP_FIELD_NAME); CodeBlock.Builder blockBuilder = CodeBlock.builder().beginControlFlow("if (index == null)"); blockBuilder.addStatement("return null"); blockBuilder.endControlFlow(); methodBuilder.addCode(blockBuilder.build()); methodBuilder.addStatement("int groupIndex = index / $L", groupSize); CodeBlock.Builder switchBuilder = CodeBlock.builder().beginControlFlow("switch(groupIndex)"); for (int groupIndex = 0; groupIndex < numGroups; groupIndex++) { switchBuilder.addStatement("case $L: return $L(index)", groupIndex, nameOfGetFromGroupMethod(groupIndex)); } switchBuilder.endControlFlow(); methodBuilder.addCode(switchBuilder.build()); methodBuilder.addStatement("return null"); classBuilder.addMethod(methodBuilder.build()); }
private void emitGetFromGroupMethod(TypeSpec.Builder classBuilder, int groupIndex) { MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(nameOfGetFromGroupMethod(groupIndex)) .addTypeVariable(typeVariable) .addModifiers(Modifier.PRIVATE) .addParameter(TypeName.INT, "index") .returns(factoryType); int groupStartIndex = groupIndex * groupSize; String typeSimpleName = registryInjectionTarget.type.getSimpleName(); CodeBlock.Builder switchBuilder = CodeBlock.builder().beginControlFlow("switch(index)"); for (int index = groupStartIndex; index < groupStartIndex + groupSize && index < classNameList.size(); index++) { switchBuilder.addStatement("case $L: return ($L<T>) new $L$$$$$L()", index, typeSimpleName, classNameList.get(index), typeSimpleName); } switchBuilder.endControlFlow(); methodBuilder.addCode(switchBuilder.build()); methodBuilder.addStatement("return null"); classBuilder.addMethod(methodBuilder.build()); }
private MethodSpec constructMethod(final Element element, final ClassName returnClazz, final String parent, final Modifier... modifiers) { final ExecutableElement templateMethod = (ExecutableElement) element; final String methodName = templateMethod.getSimpleName().toString(); final TypeName returnType = getReturnTypeDefinition(returnClazz, templateMethod); final MethodSpec.Builder methodToAdd = MethodSpec.methodBuilder(methodName) .addModifiers(modifiers) .addAnnotation(Override.class) .addExceptions(templateMethod.getThrownTypes().stream().map(TypeName::get).collect(Collectors.toList())) .returns(returnType); templateMethod.getTypeParameters().forEach(tp -> methodToAdd.addTypeVariable(TypeVariableName.get(tp))); final String parentCall = parent.isEmpty() ? "" : parent + "."; final String body = "return ($T) " + parentCall + "super.$L("; addMethodBody(methodToAdd, templateMethod, body, ")", returnClazz, methodName); return methodToAdd.build(); }
private void emitPublicGetterMethod(TypeSpec.Builder classBuilder) { MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(registryInjectionTarget.getterName) .addTypeVariable(typeVariable) .addAnnotation(Override.class) .addModifiers(Modifier.PUBLIC) .addParameter(clazzArgType, "clazz") .returns(factoryType); methodBuilder.addStatement("$T factory = $L(clazz)", factoryType, GET_FROM_THIS_REGISTRY_METHOD_NAME); CodeBlock.Builder blockBuilder = CodeBlock.builder().beginControlFlow("if (factory == null)"); blockBuilder.addStatement("return $L(clazz)", registryInjectionTarget.childrenGetterName); blockBuilder.endControlFlow(); methodBuilder.addCode(blockBuilder.build()); methodBuilder.addStatement("return factory"); classBuilder.addMethod(methodBuilder.build()); }
private static void maybeAddGenericTypeToStaticFunction( MethodParamModel methodParamModel, MethodSpec.Builder eventTriggerMethod) { if (methodParamModel.getTypeName() instanceof TypeVariableName) { eventTriggerMethod.addTypeVariable((TypeVariableName) methodParamModel.getTypeName()); } }