@Override public String generateClass(Context context, String className, String classToExtend, boolean isFinal) { String packageName = context.packageName(); ClassName superName = ClassName.get(context.autoValueClass()); Map<String, ExecutableElement> properties = context.properties(); TypeSpec subclass = TypeSpec.classBuilder(className) // .addModifiers(isFinal ? Modifier.FINAL : Modifier.ABSTRACT) // .superclass(ClassName.get(packageName, classToExtend)) // .addMethod(generateConstructor(properties)) // .addMethod(generateEquals(superName, properties)) // .addMethod(generateHashCode(superName, properties)) // .build(); JavaFile javaFile = JavaFile.builder(packageName, subclass).build(); return javaFile.toString(); }
public static void error(Context context, String message, Element element) { context.processingEnvironment().getMessager().printMessage(ERROR, message, element); }
@Override public boolean applicable(Context context) { for (ExecutableElement element : context.abstractMethods()) { if (element.getSimpleName().toString().equals("toMap")) { return true; } } return false; }
@Override public String generateClass(Context context, String className, String classToExtend, boolean isFinal) { ProcessingEnvironment env = context.processingEnvironment(); Optional<AnnotationSpec> generatedAnnotationSpec = GeneratedAnnotations.generatedAnnotation(env.getElementUtils()) .map(AutoValueGsonExtension::createGeneratedAnnotationSpec); TypeElement type = context.autoValueClass(); boolean generateExternalAdapter = type.getAnnotation(GenerateTypeAdapter.class) != null; List<Property> properties = Lists.newArrayList(); for (Map.Entry<String, ExecutableElement> entry : context.properties().entrySet()) { Property property = Property.create(context.processingEnvironment().getMessager(), entry.getKey(), entry.getValue()); if (property == null) { return null; Map<String, TypeName> types = convertPropertiesToTypes(context.properties()); ClassName classNameClass = ClassName.get(context.packageName(), className); ClassName autoValueClass = ClassName.get(context.autoValueClass()); List<? extends TypeParameterElement> typeParams = context.autoValueClass().getTypeParameters(); List<TypeVariableName> params = new ArrayList<>(typeParams.size()); ClassName superclassRawType = ClassName.get(context.packageName(), classToExtend); TypeName superclasstype = superclassRawType; if (!typeParams.isEmpty()) { superclasstype = ParameterizedTypeName.get(ClassName.get(context.packageName(), classToExtend), params.toArray(new TypeName[params.size()])); ? ClassName.get(context.packageName(), autoValueClass.simpleName() + "_GsonTypeAdapter") : classNameClass.nestedClass("GsonTypeAdapter"); ClassName finalSuperClass = generateExternalAdapter ? classNameClass : superclassRawType;
@Override public boolean applicable(Context context) { TypeElement type = context.autoValueClass(); TypeName typeName = TypeName.get(type.asType()); ParameterizedTypeName typeAdapterType = ParameterizedTypeName.get( Messager messager = context.processingEnvironment().getMessager(); if (returnedTypeAdapter instanceof ParameterizedTypeName) { ParameterizedTypeName paramReturnType = (ParameterizedTypeName) returnedTypeAdapter;
static List<WithMethod> getWithMethods(Context context) { Messager messager = context.processingEnvironment().getMessager(); Types typeUtils = context.processingEnvironment().getTypeUtils(); TypeElement autoValueClass = context.autoValueClass(); Map<String, ExecutableElement> properties = context.properties();
@Override public boolean applicable(Context context) { ProcessingEnvironment environment = context.processingEnvironment(); Xml xmlAnnotation = context.autoValueClass().getAnnotation(Xml.class); if (xmlAnnotation == null) { return false; // Auto value class not annotated with @Xml annotation throw new ProcessingException(context.autoValueClass(), "Inheritance in TikXml can't be disabled via @" + Xml.class.getSimpleName() + "(inheritance = false) in class " + context.autoValueClass().getQualifiedName()); AutoValueScannerKt.extractAutoValueProperties(context.autoValueClass(), context.properties(), context.processingEnvironment().getTypeUtils(), context.processingEnvironment().getElementUtils()); new AutoValueAnnotatedClass(context.packageName(), context.autoValueClass(), xmlAnnotation, annotatedMethods); Filer filer = context.processingEnvironment().getFiler(); JavaFile.builder(context.packageName(), AutoValueTypeAdapterCodeGeneratorKt.generateValueHolder(annotatedClass, context.processingEnvironment().getElementUtils())) .build() .writeTo(filer); JavaFile.builder(context.packageName(), AutoValueTypeAdapterCodeGeneratorKt.generateTypeAdapter(annotatedClass)) .build()
@Override public String generateClass(Context context, String classNameString, String classToExtend, boolean isFinal) { String packageName = context.packageName(); typeUtils = context.processingEnvironment().getTypeUtils(); TypeElement autoValueTypeElement = context.autoValueClass(); Map<String, ExecutableElement> properties = context.properties(); LinkedHashMap<String, TypeName> types = convertPropertiesToTypes(properties); ClassName className = ClassName.get(packageName, classNameString); TypeSpec firebaseValue = TypeSpec.classBuilder(FIREBASEVALUE) .addModifiers(STATIC, FINAL) .addAnnotations(generateFirebaseValueClassAnnotations(autoValueTypeElement)) .addFields(generateFirebaseValueFields(packageName, types)) .addFields(generateAdapterFields(types)) .addMethod(generateEmptyFirebaseValueConstructor()) .addMethod(generateFirebaseValueConstructorWithAutoValueParam( packageName, autoValueTypeElement, types)) .addMethod(generateFirebaseValueToAutoValueMethod( packageName, className, types)) .addMethod(generateToMapMethod(properties)) .addMethods(generateFirebaseValueGetters(packageName, properties)) .build(); TypeSpec generatedClass = TypeSpec.classBuilder(className) .superclass(TypeVariableName.get(classToExtend)) .addMethod(generateStandardAutoValueConstructor(types)) .addType(firebaseValue) .addModifiers(isFinal ? FINAL : ABSTRACT) .build(); return JavaFile.builder(packageName, generatedClass).build().toString(); }
@Override public String generateClass(Context context, String className, String classToExtend, boolean isFinal) { List<MapElement> valueMethods = new ArrayList<>(); for (ExecutableElement element : context.properties().values()) { MapElement item = MapElement.create(context, element); if (item != null) { valueMethods.add(item); } } ClassName superclass = ClassName.get(context.packageName(), classToExtend); ClassName trueClass = ClassName.get(context.packageName(), className.substring(className.indexOf('_') + 1)); TypeSpec.Builder subclass = TypeSpec.classBuilder(className) .addModifiers(isFinal ? Modifier.FINAL : Modifier.ABSTRACT) .addMethod(generateConstructor(valueMethods)) .addMethod(generateToMap(valueMethods)) .addMethod(generateFromMap(context, trueClass, valueMethods)); subclass.superclass(superclass); JavaFile file = JavaFile.builder(context.packageName(), subclass.build()).build(); return file.toString(); }
@Override public String generateClass( Context context, String className, String classToExtend, boolean isFinal) { ImmutableList<ColumnProperty> properties = ColumnProperty.from(context); TypeSpec.Builder subclass = newTypeSpecBuilder(context, className, classToExtend, isFinal) .addMethod(createReadMethod(context, properties)); TypeName func1TypeName = getFunc1TypeName(context); if (getMatchingStaticField(context.autoValueClass(), func1TypeName).isPresent()) { subclass.addField(createRxJava1Mapper(context, func1TypeName)); } TypeName functionTypeName = getFunctionTypeName(context); if (getMatchingStaticField(context.autoValueClass(), functionTypeName).isPresent()) { subclass.addField(createRxJava2Mapper(context, functionTypeName)); } return JavaFile.builder(context.packageName(), subclass.build()).build().toString(); }
private static ClassName getFinalClassClassName(Context context) { return ClassName.get(context.packageName(), getFinalClassSimpleName(context)); }
/** * Creates a {@link CodeBlock} that calls the constructor of the final generated class * {@link AutoValueUtil#getFinalClassClassName(Context)}. The given {@code properties} array * should either contain plain {@code String}'s or <a * href="https://github.com/square/javapoet#n-for-names">JavaPoet Names</a>. */ public static CodeBlock newFinalClassConstructorCall(Context context, Object[] properties) { CodeBlock.Builder callBuilder = CodeBlock.builder() .add("new $T", getFinalClassClassName(context)); if (context.autoValueClass().getTypeParameters().size() > 0) { callBuilder.add("<>"); } return addProperties(callBuilder, properties); }
/** * Creates a new {@link TypeSpec.Builder} for the class that is generated by the extension. It * will add a final or abstract modifier, the superclass and a constructor that calls super. The * returned TypeSpec will also include all TypeVariables if the AutoValue class is generic. */ public static TypeSpec.Builder newTypeSpecBuilder( Context context, String className, String classToExtend, boolean isFinal) { TypeVariableName[] typeVariables = getTypeVariables(context.autoValueClass()); return TypeSpec.classBuilder(className) .addModifiers(isFinal ? FINAL : ABSTRACT) .addTypeVariables(Arrays.asList(typeVariables)) .superclass(getSuperClass(context.packageName(), classToExtend, typeVariables)) .addMethod(newConstructor(context.properties())); }
@Override public String generateClass(Context context, String className, String classToExtend, boolean isFinal) { String packageName = context.packageName(); Name superName = context.autoValueClass().getSimpleName(); Map<String, ExecutableElement> properties = context.properties(); TypeSpec subclass = TypeSpec.classBuilder(className) // .addModifiers(isFinal ? Modifier.FINAL : Modifier.ABSTRACT) // .superclass(ClassName.get(packageName, classToExtend)) // .addMethod(generateConstructor(properties)) // .addMethod(generateToString(superName, properties)) // .build(); JavaFile javaFile = JavaFile.builder(packageName, subclass).build(); return javaFile.toString(); }
@Override public boolean applicable(Context context) { return getMatchingAbstractMethod(context.abstractMethods(), CONTENT_VALUES).isPresent(); }
/** * Returns the {@link ClassName} of the class annotated with * {@link com.google.auto.value.AutoValue}. */ public static TypeName getAutoValueClassTypeName(Context context) { TypeElement autoValueClass = context.autoValueClass(); ClassName autoValueClassName = ClassName.get(autoValueClass); if (autoValueClass.getTypeParameters().size() > 0) { TypeVariableName[] variables = getTypeVariables(autoValueClass); return ParameterizedTypeName.get(autoValueClassName, variables); } return autoValueClassName; }
@Override public boolean applicable(Context context) { Map<String, ExecutableElement> properties = context.properties(); for (ExecutableElement element : properties.values()) { Set<String> annotations = getAnnotations(element); annotationType = AnnotationType.from(annotations); if (annotationType == AnnotationType.ERROR) { throw new RuntimeException("Annotations are mutually exclusive, " + "only one annotation type can be included at the same time."); } if (annotationType != AnnotationType.NOT_PRESENT) { return true; } } return false; }
private static String getFinalClassSimpleName(Context context) { TypeElement autoValueClass = context.autoValueClass(); String name = autoValueClass.getSimpleName().toString(); Element enclosingElement = autoValueClass.getEnclosingElement(); while (enclosingElement instanceof TypeElement) { name = enclosingElement.getSimpleName().toString() + "_" + name; enclosingElement = enclosingElement.getEnclosingElement(); } return "AutoValue_" + name; }
@Override public boolean applicable(Context context) { TypeElement valueClass = context.autoValueClass(); return getMatchingStaticMethod(valueClass, ClassName.get(valueClass), CURSOR).isPresent() || getMatchingStaticField(valueClass, getFunc1TypeName(context)).isPresent() || getMatchingStaticField(valueClass, getFunctionTypeName(context)).isPresent(); }
public static ImmutableList<ColumnProperty> from(AutoValueExtension.Context context) { ImmutableList.Builder<ColumnProperty> values = ImmutableList.builder(); for (Map.Entry<String, ExecutableElement> entry : context.properties().entrySet()) { values.add(new ColumnProperty(entry.getKey(), entry.getValue())); } return values.build(); }