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(); .addModifiers(Modifier.PUBLIC) .addCode(rootCode.build()) .build(); TypeSpec adapterClass = TypeSpec.classBuilder("ConverterRegister") .addJavadoc(Constants.DOC_EDIT_WARN) .addModifiers(Modifier.PUBLIC, Modifier.FINAL) .addSuperinterface(mOnRegisterType) .addField(mapField) .addMethod(rootMethod)
private <T extends Type> void generateIntTypes( Class<T> superclass, String path) throws IOException { String packageName = createPackageName(superclass); ClassName className; for (int bitSize = 8; bitSize <= Type.MAX_BIT_LENGTH; bitSize += 8) { className = ClassName.get(packageName, superclass.getSimpleName() + bitSize); MethodSpec constructorSpec = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(BigInteger.class, "value") .addStatement("super($L, $N)", bitSize, "value") .build(); MethodSpec overideConstructorSpec = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(long.class, "value") .addStatement("this(BigInteger.valueOf(value))") .build(); FieldSpec defaultFieldSpec = FieldSpec .builder(className, DEFAULT, Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .initializer("new $T(BigInteger.ZERO)", className) .build(); TypeSpec intType = TypeSpec.classBuilder(className.simpleName()) .addJavadoc(CODEGEN_WARNING) .superclass(superclass) .addModifiers(Modifier.PUBLIC) .addField(defaultFieldSpec) .addMethods(Arrays.asList(constructorSpec, overideConstructorSpec)) .build(); write(packageName, intType, path); } }
private void addUsedTypeConverterMethods(TypeSpec.Builder builder) { Set<TypeName> usedTypeConverters = new HashSet<>(); for (JsonFieldHolder holder : mJsonObjectHolder.fieldMap.values()) { usedTypeConverters.addAll(holder.type.getUsedTypeConverters()); } for (TypeName usedTypeConverter : usedTypeConverters) { final String variableName = getTypeConverterVariableName(usedTypeConverter); builder.addField(FieldSpec.builder(ParameterizedTypeName.get(ClassName.get(TypeConverter.class), usedTypeConverter), variableName) .addModifiers(Modifier.PRIVATE, Modifier.STATIC) .build() ); builder.addMethod(MethodSpec.methodBuilder(getTypeConverterGetter(usedTypeConverter)) .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL) .returns(ParameterizedTypeName.get(ClassName.get(TypeConverter.class), usedTypeConverter)) .beginControlFlow("if ($L == null)", variableName) .addStatement("$L = $T.typeConverterFor($T.class)", variableName, LoganSquare.class, usedTypeConverter) .endControlFlow() .addStatement("return $L", variableName) .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 .builder(mapStringString, "_addresses", 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) -> k, v)) ); classBuilder.addStaticBlock(staticInit.build()); .addCode( CodeBlock .builder() .addStatement("return _addresses.get(networkId)") .build())
public static <T extends Element> ImmutableList<FieldModel> extractFields(T element) { final List<FieldModel> fields = new ArrayList<>(); for (Element enclosedElement : element.getEnclosedElements()) { if (ElementKind.FIELD.equals(enclosedElement.getKind())) { Set<Modifier> modifiers = enclosedElement.getModifiers(); fields.add( new FieldModel( FieldSpec.builder( TypeName.get(enclosedElement.asType()), enclosedElement.getSimpleName().toString(), modifiers.toArray(new Modifier[modifiers.size()])) .build(), enclosedElement)); } } return ImmutableList.copyOf(fields); } }
String cachedValueName) { TypeSpec.Builder typeSpec = TypeSpec.classBuilder(getInputsClassName(cachedValueName)) .addModifiers(Modifier.PRIVATE, Modifier.STATIC); typeSpec.addField( FieldSpec.builder(param.getTypeName(), param.getName(), Modifier.PRIVATE, Modifier.FINAL) .build()); constructor .addParameter(ParameterSpec.builder(param.getTypeName(), param.getName()).build()) .addStatement("this.$L = $L", param.getName(), param.getName()); typeSpec.addMethod(constructor.build()); .addModifiers(Modifier.PUBLIC); CodeBlock.Builder codeBlock = CodeBlock.builder().add("return $T.hash(", ClassNames.OBJECTS); for (int i = 0, size = onCalculateCachedValueMethod.methodParams.size(); i < size; i++) { if (i < size - 1) {
.addAnnotation(Override.class) .addAnnotation( AnnotationSpec .builder(SuppressWarnings.class) .build() .addModifiers(Modifier.PUBLIC) CodeBlock.Builder staticInitBlock = CodeBlock.builder(); TypeSpec classBuilder = TypeSpec.classBuilder(className + STATE_SAVER_SUFFIX) .addModifiers(Modifier.PUBLIC) .superclass(superTypeName) .addTypeVariable(genericType) .addField( FieldSpec.builder(bundlerMap, "BUNDLERS") .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL) .initializer("new $T()", bundlerMap) .build() FieldSpec.builder(getTypeName(INJECTION_HELPER_CLASS_NAME), "HELPER") .addModifiers(Modifier.FINAL, Modifier.STATIC, Modifier.PRIVATE) .initializer("new $T($S, $N)", getTypeName(INJECTION_HELPER_CLASS_NAME), packageName + '.' + className + STATE_SAVER_SUFFIX, "BUNDLERS") .build()
TypeSpec.Builder widgetContainerBuilder = TypeSpec.classBuilder(mWidgetContainerName); FieldSpec instanceField = FieldSpec.builder(mWidgetContainerName, "sInstance") .addModifiers(Modifier.PRIVATE) .addModifiers(Modifier.STATIC) .initializer("new $T()", mWidgetContainerName) .build(); FieldSpec mapField = FieldSpec.builder(mMapFieldTypeName, "mWidgets") .addModifiers(Modifier.PRIVATE) .build(); .addModifiers(Modifier.PRIVATE) .addStatement("mWidgets = new $T<>()", mHashMapName); ClassName elementName = ClassName.get(classElement); Widget widget = classElement.getAnnotation(Widget.class); String name = null; error("please provide widgetClass or name"); constructorBuilder.addStatement("mWidgets.put($T.class, new $T($T.class, $S, $L))", elementName, mItemDescName,
final CodeBlock.Builder argAssignment = CodeBlock.builder(); args.getArgs().forEach((name, argExpr) -> { final Object varRef = blockOrMissing(codeSnippet.get(argExpr), argExpr); varRef); }); currentMethod.addCode(argAssignment.build()); CodeBlock functionInvocation = CodeBlock.of("$L.evaluate($L, context)", mangledFunctionName, mangledFuncArgsHolder); currentMethod.addStatement("$L", functionInvocation); } else { currentMethod.addStatement("$T $L = $L", ClassName.get(function.returnType()), functionValueVarName, functionInvocation); FieldSpec.builder(expr.getFunction().getClass(), mangledFunctionName, Modifier.PRIVATE, Modifier.FINAL) .build()); functionReferences.add(CodeBlock.of("$L = ($T) functionRegistry.resolve($S)", mangledFunctionName, expr.getFunction().getClass(),
String writer = nameAllocator.get("writer"); TypeSpec.Builder builder = TypeSpec.classBuilder(adapterJavaType.simpleName()); builder.superclass(adapterOf(javaType)); builder.addModifiers(PUBLIC); constructorBuilder.addModifiers(PUBLIC); constructorBuilder.addStatement("super($T.VARINT, $T.class)", FieldEncoding.class, javaType); for (EnumConstant constant : type.constants()) { String name = nameAllocator.get(constant); FieldSpec.Builder fieldBuilder = FieldSpec.builder(javaType, name) .addModifiers(PROTECTED, FINAL); if (!constant.documentation().isEmpty()) { fieldBuilder.addJavadoc("$L\n", sanitizeJavadoc(constant.documentation())); fieldBuilder.addAnnotation(Deprecated.class); builder.addField(fieldBuilder.build()); constructorBuilder.addParameter(javaType, name); constructorBuilder.addStatement("this.$N = $N", name, name);
FieldSpec age = FieldSpec.builder(int.class, "age") .addModifiers(Modifier.PRIVATE) .build(); FieldSpec name = FieldSpec.builder(String.class, "name") .addModifiers(Modifier.PRIVATE) .initializer("$S", "qiyue") .build(); MethodSpec constructorMethod = MethodSpec.constructorBuilder() .addModifiers(Modifier.PUBLIC) .addParameter(String.class, "name") .addStatement("this.$N = $N", "name", "name") .build(); MethodSpec getAgeMethod = MethodSpec.methodBuilder("getAge") .build(); TypeSpec typeSpec = TypeSpec.classBuilder("Person") .addModifiers(Modifier.PUBLIC) .addMethod(getNameMethod) .addMethod(getAgeMethod) .addMethod(constructorMethod) .addField(age)
FieldSpec.builder(stateValue.getTypeName(), stateValue.getName()) .addAnnotation(State.class) .addAnnotation( AnnotationSpec.builder(Comparable.class) .addMember("type", "$L", getComparableType(specModel, stateValue)) .build()) .build()); FieldSpec.builder( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box()), GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME) .initializer("new $T<>()", ClassNames.ARRAY_LIST) .build()); .addModifiers(Modifier.PUBLIC) .addAnnotation(Override.class) .returns( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box())) .addCode( CodeBlock.builder() .beginControlFlow( "if ($L.isEmpty())", GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME)
static TypeSpec generatePreviousRenderDataContainerImpl(SpecModel specModel) { final String className = RenderDataGenerator.getRenderDataImplClassName(specModel); final TypeSpec.Builder renderInfoClassBuilder = TypeSpec.classBuilder(className).addSuperinterface(ClassNames.RENDER_DATA); renderInfoClassBuilder.addModifiers(Modifier.STATIC, Modifier.PRIVATE); renderInfoClassBuilder.addTypeVariables(specModel.getTypeVariables()); final String recordParamName = "component"; final MethodSpec.Builder copyBuilder = MethodSpec.methodBuilder("copy") .addParameter(ClassName.bestGuess(className), copyParamName); final MethodSpec.Builder recordBuilder = MethodSpec.methodBuilder("record") .addParameter(specModel.getComponentTypeName(), recordParamName); renderInfoClassBuilder.addField(FieldSpec.builder( modelToDiff.getTypeName(), name).addAnnotation(Prop.class).build()); } else { renderInfoClassBuilder.addField(FieldSpec.builder( modelToDiff.getTypeName(), modelToDiff.getName()).addAnnotation(State.class).build()); copyBuilder.addStatement("$L = $L.$L", name, copyParamName, name); recordBuilder.addStatement( "$L = $L.$L",
ClassName builderJavaType = javaType.nestedClass("Builder"); builder.addJavadoc("$L\n", sanitizeJavadoc(type.documentation())); TypeName creatorType = creatorOf(javaType); String creatorName = nameAllocator.get("CREATOR"); builder.addField(FieldSpec.builder(creatorType, creatorName, PUBLIC, STATIC, FINAL) .initializer("$T.newCreator($L)", ANDROID_MESSAGE, adapterName) .build()); builder.addField(FieldSpec.builder(TypeName.LONG, nameAllocator.get("serialVersionUID")) .addModifiers(PRIVATE, STATIC, FINAL) .initializer("$LL", 0L) .build()); FieldSpec.Builder fieldBuilder = FieldSpec.builder(fieldJavaType, fieldName, PUBLIC, FINAL); fieldBuilder.addAnnotation(wireFieldAnnotation(field)); if (!field.documentation().isEmpty()) { fieldBuilder.addJavadoc("$L\n", sanitizeJavadoc(field.documentation())); fieldBuilder.addJavadoc("Extension source: $L\n", field.location().withPathOnly()); fieldBuilder.addAnnotation(Deprecated.class); fieldBuilder.addAnnotation(NULLABLE); builder.addField(fieldBuilder.build());
private FieldSpec optionsField(ProtoType optionsType, String fieldName, Options options) { TypeName optionsJavaType = typeName(optionsType); CodeBlock.Builder initializer = CodeBlock.builder(); initializer.add("$[new $T.Builder()", optionsJavaType); boolean empty = true; for (Map.Entry<ProtoMember, ?> entry : options.map().entrySet()) { if (entry.getKey().equals(FIELD_DEPRECATED) || entry.getKey().equals(PACKED)) { continue; } Field optionField = schema.getField(entry.getKey()); initializer.add("\n.$L($L)", fieldName(optionsType, optionField), fieldInitializer(optionField.type(), entry.getValue())); empty = false; } initializer.add("\n.build()$]"); if (empty) return null; return FieldSpec.builder(optionsJavaType, fieldName) .addModifiers(PUBLIC, STATIC, FINAL) .initializer(initializer.build()) .build(); }
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); typeSpecDataHolder.addField( FieldSpec.builder(poolType, poolName, Modifier.STATIC, Modifier.FINAL) .initializer("new $T(2)", poolType) .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(); final CodeBlock.Builder resetCode = CodeBlock.builder(); for (FieldModel fieldModel : eventDeclaration.fields) { if (fieldModel.field.modifiers.contains(Modifier.FINAL)) {
ClassName javaType = (ClassName) typeName(type.type()); TypeSpec.Builder builder = TypeSpec.enumBuilder(javaType.simpleName()) .addModifiers(PUBLIC) .addSuperinterface(WireEnum.class); builder.addJavadoc("$L\n", sanitizeJavadoc(type.documentation())); constructorBuilder.addStatement("this.$1N = $1N", value); constructorBuilder.addParameter(TypeName.INT, value); TypeSpec.Builder constantBuilder = TypeSpec.anonymousClassBuilder(enumArgsFormat, enumArgs); if (!constant.documentation().isEmpty()) { constantBuilder.addJavadoc("$L\n", sanitizeJavadoc(constant.documentation())); FieldSpec.Builder adapterBuilder = FieldSpec.builder(adapterOf(javaType), "ADAPTER") .addModifiers(PUBLIC, STATIC, FINAL); ClassName adapterJavaType = javaType.nestedClass("ProtoAdapter_" + javaType.simpleName()); if (!emitCompact) { adapterBuilder.initializer("new $T()", adapterJavaType); } else { adapterBuilder.initializer("$T.newEnumAdapter($T.class)", ProtoAdapter.class, javaType); builder.addField(adapterBuilder.build());
@Nonnull private String functionArgsHolder(FunctionDescriptor<?> function) { // create the argument holder for the function invocation (and create the holder class if it doesn't exist yet) final String functionArgsClassname = functionArgsHolderClass(function); final String functionArgsMember = functionReference(function) + "$" + subExpressionName(); classFile.addField(FieldSpec.builder( ClassName.bestGuess(functionArgsClassname), functionArgsMember, Modifier.PRIVATE) .build()); lateConstructorBlock.addStatement("$L = new $L()", functionArgsMember, functionArgsClassname); return functionArgsMember; }
public Builder addAnnotation(Class<?> annotation) { return addAnnotation(ClassName.get(annotation)); }
@Override public void exitArrayLiteral(ArrayLiteralExpression expr) { final String listName = "arrayLiteral$" + subExpressionName(); final boolean constantList = expr.isConstant(); final ImmutableList.Builder<Object> elementsBuilder = ImmutableList.builder(); expr.children().forEach(expression -> elementsBuilder.add(blockOrMissing(codeSnippet.get(expression), expression))); final ImmutableList<Object> elements = elementsBuilder.build(); // if possible hoist decl to constructor if (constantList) { hoistedExpressionMembers.add(FieldSpec.builder(List.class, listName, Modifier.PRIVATE, Modifier.FINAL).build()); } final String assignmentFormat = "$L = $T.newArrayList(" + Stream.generate(() -> "$L").limit(elements.size()).reduce(Joiner.on(", ")::join).orElseGet(() -> "$") + ")"; // sigh java varargs List<Object> args = Lists.newArrayList(ArrayList.class, listName, Lists.class); args.addAll(elements); // if constant, initialize completely in constructor if (constantList) { hoistedConstantExpressions.addStatement(assignmentFormat, args.subList(1, args.size()).toArray()); } else { currentMethod.addStatement("$T " + assignmentFormat, args.toArray()); } codeSnippet.putIfAbsent(expr, CodeBlock.of("$L", listName)); }