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()); }
/** Returns a parameterized type equivalent to {@code type}. */ static ParameterizedTypeName get(ParameterizedType type, Map<Type, TypeVariableName> map) { ClassName rawType = ClassName.get((Class<?>) type.getRawType()); ParameterizedType ownerType = (type.getOwnerType() instanceof ParameterizedType) && !Modifier.isStatic(((Class<?>) type.getRawType()).getModifiers()) ? (ParameterizedType) type.getOwnerType() : null; List<TypeName> typeArguments = TypeName.list(type.getActualTypeArguments(), map); return (ownerType != null) ? get(ownerType, map).nestedClass(rawType.simpleName(), typeArguments) : new ParameterizedTypeName(null, rawType, typeArguments); } }
@Override public ParameterizedTypeName annotated(List<AnnotationSpec> annotations) { return new ParameterizedTypeName( enclosingType, rawType, typeArguments, concatAnnotations(annotations)); }
/** Returns a parameterized type, applying {@code typeArguments} to {@code rawType}. */ public static ParameterizedTypeName get(Class<?> rawType, Type... typeArguments) { return new ParameterizedTypeName(null, ClassName.get(rawType), list(typeArguments)); }
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(); }
Strings.lowercaseFirstLetter(functionName) + "EventFlowable"; ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(ClassName.get(Flowable.class), ClassName.get("", responseClassName)); 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) .addStatement("return typedResponse") .build()) .build();
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") .addParameter(int.class, "defStyleRes") .addParameter(componentClass, componentInstanceRefName) TypeSpec.classBuilder(BUILDER) .addModifiers(Modifier.PUBLIC, Modifier.STATIC) .superclass( ParameterizedTypeName.get( ClassName.get( specModel.getComponentClass().packageName(), specModel.getComponentClass().simpleName(), BUILDER), builderType)) .addField(componentClass, componentMemberInstanceName) .addField(specModel.getContextClass(), CONTEXT_MEMBER_NAME); MethodSpec.Builder initResTypePropDefaultsSpec = MethodSpec.methodBuilder("initPropDefaults");
@Override protected TypeSpec.Builder createClassBuilder() { ClassName parentClassName = getClassDetail().getGeneratedClassName(); ClassName generatedClassName = ClassName.get( getClassDetail().getPackageName(), getClassDetail().getTypeName() + BindingSuffix.CLASS_LOAD_MORE_VIEW_BINDER_SUFFIX); ClassName loadMoreCallbackClassName = ClassName.get( NameStore.Package.PLACE_HOLDER_VIEW, NameStore.Class.LOAD_MORE_CALLBACK_BINDER); return TypeSpec.classBuilder(generatedClassName) .superclass(parentClassName) .addSuperinterface(ParameterizedTypeName.get(loadMoreCallbackClassName, TypeVariableName.get(getClassDetail().getTypeElement().asType()))) .addModifiers(Modifier.PUBLIC) .addAnnotation(Keep.class); }
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) .addTypeVariables(specModel.getTypeVariables()); stateContainerClassBuilder.addField( FieldSpec.builder( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box()), GeneratorConstants.STATE_TRANSITIONS_FIELD_NAME) .initializer("new $T<>()", ClassNames.ARRAY_LIST) stateContainerClassBuilder.addMethod( MethodSpec.methodBuilder("consumeTransitions") .addModifiers(Modifier.PUBLIC) .addAnnotation(Override.class) .returns( ParameterizedTypeName.get(ClassNames.LIST, specModel.getTransitionClass().box())) .addCode( CodeBlock.builder()
private static TypeName getMatcherConditionTypeName() { return ParameterizedTypeName.get( ClassNames.ASSERTJ_CONDITION, ClassNames.INSPECTABLE_COMPONENT); }
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);
public static void main(String[] args){ //generateSharedProperties(); //generateSharedProperties2(); // testGenerateProxy(); testToStringBuilder(); //com.heaven.TestOutter.TestInner /* ClassName className = ClassName.get("com.heaven","TestOutter.TestInner"); System.out.println(className.toString());*/ final ParameterizedTypeName name = ParameterizedTypeName.get( ClassName.get("xx", "heaven7"), ClassName.get("","T") ); System.out.println(name.toString()); }
@Override protected TypeSpec.Builder createClassBuilder() { return TypeSpec.classBuilder(getClassDetail().getGeneratedClassName()) .superclass(ParameterizedTypeName.get( getClassDetail().getSuperClassName(), TypeVariableName.get(getClassDetail().getTypeElement().asType()), getClassDetail().getFrameViewClassName(), getClassDetail().getSwipeOptionClassName(), getClassDetail().getSwipeDecorClassName())) .addModifiers(Modifier.PUBLIC) .addAnnotation(Keep.class); }
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) 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)
@Override protected TypeSpec.Builder createClassBuilder() { return TypeSpec.classBuilder(getClassDetail().getGeneratedClassName()) .superclass(ParameterizedTypeName.get( getClassDetail().getSuperClassName(), TypeVariableName.get(getClassDetail().getTypeElement().asType()), TypeVariableName.get(getClassDetail().getViewTypeParameterClassName().simpleName()))) .addModifiers(Modifier.PUBLIC) .addAnnotation(Keep.class); }
private void generateHelperClassForController(ControllerClassInfo controllerInfo) throws IOException { ParameterizedTypeName parameterizeSuperClass = ParameterizedTypeName .get(ClassNames.EPOXY_CONTROLLER_HELPER, controllerInfo.getControllerClassType()); TypeSpec.Builder builder = TypeSpec.classBuilder(controllerInfo.getGeneratedClassName()) .addJavadoc("Generated file. Do not modify!") .addModifiers(Modifier.PUBLIC) .superclass(parameterizeSuperClass) .addField(controllerInfo.getControllerClassType(), "controller", Modifier.FINAL, Modifier.PRIVATE) .addMethod(buildConstructor(controllerInfo)) .addMethod(buildResetModelsMethod(controllerInfo)); if (configManager.shouldValidateModelUsage()) { builder.addFields(buildFieldsToSaveModelsForValidation(controllerInfo)) .addMethod(buildValidateModelsHaveNotChangedMethod(controllerInfo)) .addMethod(buildValidateSameValueMethod()) .addMethod(buildSaveModelsForNextValidationMethod(controllerInfo)); } JavaFile.builder(controllerInfo.getGeneratedClassName().packageName(), builder.build()) .build() .writeTo(filer); }
private static TypeName bestGuess(String type) { switch (type) { case "void": return TypeName.VOID; case "boolean": return TypeName.BOOLEAN; case "byte": return TypeName.BYTE; case "char": return TypeName.CHAR; case "double": return TypeName.DOUBLE; case "float": return TypeName.FLOAT; case "int": return TypeName.INT; case "long": return TypeName.LONG; case "short": return TypeName.SHORT; default: int left = type.indexOf('<'); if (left != -1) { ClassName typeClassName = ClassName.bestGuess(type.substring(0, left)); List<TypeName> typeArguments = new ArrayList<>(); do { typeArguments.add(WildcardTypeName.subtypeOf(Object.class)); left = type.indexOf('<', left + 1); } while (left != -1); return ParameterizedTypeName.get(typeClassName, typeArguments.toArray(new TypeName[typeArguments.size()])); } return ClassName.bestGuess(type); } }
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));
@Test public void testDiffModelHasDifferentParameterFromState() { when(mDiffModel.getTypeName()).thenReturn( ParameterizedTypeName.get(ClassNames.DIFF, TypeName.BOOLEAN.box()) .annotated(AnnotationSpec.builder(State.class).build())); List<SpecModelValidationError> validationErrors = DiffValidation.validate(mSpecModel); assertSingleError(validationErrors, DiffValidation.STATE_MISMATCH_ERROR); }