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); } }
static <S extends SpecModel> Collection<SpecModelValidationError> validate(S specModel) { List<SpecModelValidationError> validationErrors = new ArrayList<>(); for (FieldModel field : specModel.getFields()) { if (!(field.field.hasModifier(Modifier.FINAL) && field.field.hasModifier(Modifier.STATIC))) { validationErrors.add( new SpecModelValidationError( field.representedObject, field.field.name + " should be declared static and final.")); } } return validationErrors; } }
@Override public int hashCode() { return toString().hashCode(); }
ClassName moduleClassName = ClassName.get(type); ClassName adapterClassName = Util.adapterName(moduleClassName, MODULE_ADAPTER_SUFFIX); TypeSpec.Builder adapterBuilder = TypeSpec.classBuilder(adapterClassName.simpleName()) .addOriginatingElement(type) .addJavadoc(AdapterJavadocs.MODULE_TYPE, Provides.class) .superclass(ParameterizedTypeName.get(ClassName.get(ModuleAdapter.class), moduleClassName)) adapterBuilder.addField(FieldSpec.builder(String[].class, "INJECTS") .addModifiers(PRIVATE, STATIC, FINAL) .initializer("$L", injectsInitializer(injects)) .build()); adapterBuilder.addField(FieldSpec.builder(ARRAY_OF_CLASS, "STATIC_INJECTIONS") adapterBuilder.addField(FieldSpec.builder(ARRAY_OF_CLASS, "INCLUDES") adapterBuilder.addMethod(MethodSpec.constructorBuilder() .addModifiers(PUBLIC) .addStatement("super($T.class, INJECTS, STATIC_INJECTIONS, $L /*overrides*/, " + "INCLUDES, $L /*complete*/, $L /*library*/)", type.asType(), overrides, complete, library) .build()); adapterBuilder.addMethod(MethodSpec.methodBuilder("newModule") MethodSpec.Builder getBindings = MethodSpec.methodBuilder("getBindings")
final String componentInstanceRefName = ComponentBodyGenerator.getInstanceRefName(specModel); final String componentMemberInstanceName = getComponentMemberInstanceName(specModel); final ClassName componentClass = ClassName.bestGuess(componentName); final MethodSpec.Builder initMethodSpec = MethodSpec.methodBuilder("init") .addModifiers(Modifier.PRIVATE) .addParameter(specModel.getContextClass(), CONTEXT_PARAM_NAME); .addParameter(int.class, "defStyleAttr") builderType)) .addField(componentClass, componentMemberInstanceName) FieldSpec.builder(String[].class, REQUIRED_PROPS_NAMES, Modifier.PRIVATE, Modifier.FINAL) .initializer("new String[] {$L}", commaSeparateAndQuoteStrings(requiredPropNames)) .build()); FieldSpec.builder(int.class, REQUIRED_PROPS_COUNT, Modifier.PRIVATE, Modifier.FINAL) .initializer("$L", numRequiredProps) FieldSpec.builder(BitSet.class, "mRequired", Modifier.PRIVATE, Modifier.FINAL) MethodSpec.Builder initResTypePropDefaultsSpec = MethodSpec.methodBuilder("initPropDefaults");
private void addUsedJsonMapperVariables(TypeSpec.Builder builder) { Set<ClassNameObjectMapper> usedJsonObjectMappers = new HashSet<>(); for (JsonFieldHolder holder : mJsonObjectHolder.fieldMap.values()) { usedJsonObjectMappers.addAll(holder.type.getUsedJsonObjectMappers()); } for (ClassNameObjectMapper usedJsonObjectMapper : usedJsonObjectMappers) { builder.addField(FieldSpec.builder(ParameterizedTypeName.get(ClassName.get(JsonMapper.class), usedJsonObjectMapper.className), getMapperVariableName(usedJsonObjectMapper.objectMapper)) .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL) .initializer("$T.mapperFor($T.class)", LoganSquare.class, usedJsonObjectMapper.className) .build() ); } }
MethodSpec.Builder saveMethodBuilder = MethodSpec.methodBuilder("save") .addAnnotation(Override.class) .addAnnotation( AnnotationSpec .builder(SuppressWarnings.class) .build() .addModifiers(Modifier.PUBLIC) MethodSpec.Builder restoreMethodBuilder = MethodSpec.methodBuilder("restore") 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")
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 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 javaType = (ClassName) typeName(type.type()); TypeSpec.Builder builder = TypeSpec.enumBuilder(javaType.simpleName()) .addModifiers(PUBLIC) .addSuperinterface(WireEnum.class); builder.addJavadoc("$L\n", sanitizeJavadoc(type.documentation())); MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder(); constructorBuilder.addStatement("this.$1N = $1N", value); constructorBuilder.addParameter(TypeName.INT, value); constructorBuilder.addParameter(optionJavaType, optionField.name()); MethodSpec.Builder fromValueBuilder = MethodSpec.methodBuilder("fromValue") TypeSpec.Builder constantBuilder = TypeSpec.anonymousClassBuilder(enumArgsFormat, enumArgs); 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.addMethod(MethodSpec.methodBuilder("getValue")
private static JavaFile createParameterCodeEnum(String packageName, String sharedDir) { TypeSpec.Builder builder = TypeSpec.classBuilder(PARAMETER_CODE).addModifiers(Modifier.PUBLIC); Set<String> params = SyncParameterCodes.getAllParameterCodes(sharedDir); for (String entry : params) { builder.addField(FieldSpec.builder(String.class, entry) .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .initializer("$S", entry) .build()); } TypeSpec typeSpec = builder.build(); return JavaFile.builder(packageName, typeSpec).build(); } }
public static Builder builder(Type type, String name, Modifier... modifiers) { return builder(TypeName.get(type), name, modifiers); }
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() ); } }
static TypeSpec generateStateContainer(SpecModel specModel) { final TypeSpec.Builder stateContainerClassBuilder = TypeSpec.classBuilder(getStateContainerClassName(specModel)) .addSuperinterface(specModel.getStateContainerClass()) .addAnnotation( AnnotationSpec.builder(VisibleForTesting.class) .addMember("otherwise", "$L", VisibleForTesting.PRIVATE) .build()) .addModifiers(Modifier.STATIC) 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()), MethodSpec.methodBuilder("consumeTransitions") .addModifiers(Modifier.PUBLIC) .addAnnotation(Override.class) .returns( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box()))
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) .build()); MethodSpec.constructorBuilder() .addParameter(specModel.getContextClass(), "c") .addStatement("$L = new $T(c)", RESOURCE_RESOLVER, ClassNames.RESOURCE_RESOLVER) .build(); propsBuilderClassBuilder.addMethod(constructor);
/** * Generates the class code and writes to a new source file. * * @param filer Annotation filer instance provided by {@link BarberProcessor} * @throws IOException */ void writeToFiler(Filer filer) throws IOException { ClassName targetClassName = ClassName.get(classPackage, targetClass); TypeSpec.Builder barberShop = TypeSpec.classBuilder(className) .addModifiers(Modifier.PUBLIC) .addTypeVariable(TypeVariableName.get("T", targetClassName)) .addMethod(generateStyleMethod()) .addMethod(generateCheckParentMethod()); if (parentBarbershop == null) { barberShop.addSuperinterface(ParameterizedTypeName.get(ClassName.get(Barber.IBarbershop.class), TypeVariableName.get("T"))); barberShop.addField(FieldSpec.builder(WeakHashSet.class, "lastStyledTargets", Modifier.PROTECTED).initializer("new $T()", WeakHashSet.class).build()); } else { barberShop.superclass(ParameterizedTypeName.get(ClassName.bestGuess(parentBarbershop), TypeVariableName.get("T"))); } JavaFile javaFile = JavaFile.builder(classPackage, barberShop.build()).build(); javaFile.writeTo(filer); }
private void addRxEventClassContent(TypeSpec.Builder typeBuilder, String eventClassName) { Class<?> factoryClass = getRxFactoryClass(); if (factoryClass == null) { return; } typeBuilder.addField(FieldSpec.builder(ParameterizedTypeName.get(ClassName.get(rxFactoryClass), ClassName.bestGuess(eventClassName)), "Rx", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL) .initializer("new $L<>($L.class)", rxFactoryClass.getName(), eventClassName).build()); typeBuilder.addMethod(MethodSpec.methodBuilder("onSent") .addModifiers(Modifier.PUBLIC) .addParameter(ClassName.bestGuess("com.edisonwang.ps.lib.EventManager.EventServiceResponseHandler"), "handler") .addStatement("super.onSent(handler)") .addStatement("Rx.send(this)").build()); }
protected void generateProducerField() { //log.info("Generate field: "+PRODUCER_FIELD); TypeName producerTypeName = TypeName.get(iocletElement.getOriginProducer().asClassType().unwrap()); TypeName fieldType = ParameterizedTypeName.get(ClassName.get(LazySingleton.class), producerTypeName); FieldSpec.Builder fb = FieldSpec.builder(fieldType, PRODUCER_FIELD); fb.addModifiers(Modifier.PRIVATE, Modifier.FINAL); MethodSpec.Builder mb = MethodSpec.methodBuilder(LazySingleton.CREATE_METHOD); mb.addModifiers(Modifier.PUBLIC, Modifier.FINAL); mb.returns(producerTypeName); mb.addStatement("return new $T()", producerTypeName); mb.addAnnotation(Override.class); TypeSpec.Builder tb = TypeSpec.anonymousClassBuilder(""); tb.superclass(fieldType); tb.addMethod(mb.build()); fb.initializer("$L", tb.build()); classBuilder.addField(fb.build()); }
default void addToConfig(@NonNull TypeSpec.Builder builder, @NonNull MethodSpec.Builder constructor) { //add field final TypeName type = Types.getImmutableType(getType()); builder.addField(FieldSpec.builder(type, getName(), Modifier.PRIVATE, Modifier.FINAL).addAnnotations(getAnnotations()).build()); if (!type.equals(getType())) { constructor.addStatement("$1L = new $2T($3L.$1L())", getName(), type, PARAM_0); } else { constructor.addStatement("$1L = $2L.$1L()", getName(), PARAM_0); } //add getter builder.addMethod(MethodSpec.methodBuilder(getName()) .addAnnotations(getAnnotations()) .returns(type) .addStatement("return $L", getName()) .addModifiers(Modifier.PUBLIC) .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)
ClassName builderJavaType = javaType.nestedClass("Builder"); TypeSpec.Builder builder = TypeSpec.classBuilder(javaType.simpleName()); builder.addModifiers(PUBLIC, FINAL); if (javaType.enclosingClassName() != null) { builder.addModifiers(STATIC); 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()) {