From 0710971dbb9cf0696a05783070813c2b3b709d74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jyri-Matti=20La=CC=88hteenma=CC=88ki?= Date: Thu, 4 Jan 2024 14:09:00 +0200 Subject: [PATCH] possibility to disable other generators --- pom.xml | 2 +- .../utils/meta/CommonMetadataProcessor.java | 57 ++++++++++++++----- .../utils/meta/ForceMetadataGeneration.java | 3 + .../java/fi/solita/utils/meta/Helpers.java | 38 +++++++++++-- .../generators/ConstructorsAsFunctions.java | 1 - .../solita/utils/meta/generators/Content.java | 4 +- .../meta/generators/InstanceFieldsAsEnum.java | 25 +++++--- .../generators/InstanceFieldsAsFunctions.java | 41 +++++++------ .../generators/InstanceFieldsAsTuple.java | 20 ++++--- .../meta/generators/MethodsAsFunctions.java | 3 +- 10 files changed, 135 insertions(+), 59 deletions(-) diff --git a/pom.xml b/pom.xml index 0fb28ae..401897f 100644 --- a/pom.xml +++ b/pom.xml @@ -2,7 +2,7 @@ 4.0.0 fi.solita.utils meta-utils - 0.12.27 + 0.12.31 diff --git a/src/main/java/fi/solita/utils/meta/CommonMetadataProcessor.java b/src/main/java/fi/solita/utils/meta/CommonMetadataProcessor.java index e8243aa..e09532a 100644 --- a/src/main/java/fi/solita/utils/meta/CommonMetadataProcessor.java +++ b/src/main/java/fi/solita/utils/meta/CommonMetadataProcessor.java @@ -74,7 +74,10 @@ "CommonMetadataProcessor." + CommonMetadataProcessor.Options.includesAnnotation, "CommonMetadataProcessor." + CommonMetadataProcessor.Options.excludesAnnotation, "CommonMetadataProcessor." + CommonMetadataProcessor.Options.methodsAsFunctionsEnabled, - "CommonMetadataProcessor." + CommonMetadataProcessor.Options.constructorsAsFunctionsEnabled}) + "CommonMetadataProcessor." + CommonMetadataProcessor.Options.constructorsAsFunctionsEnabled, + "CommonMetadataProcessor." + CommonMetadataProcessor.Options.instanceFieldsAsEnumEnabled, + "CommonMetadataProcessor." + CommonMetadataProcessor.Options.instanceFieldsAsFunctionsEnabled, + "CommonMetadataProcessor." + CommonMetadataProcessor.Options.instanceFieldsAsTupleEnabled}) public class CommonMetadataProcessor extends AbstractProcessor { private static final int version = 1; @@ -91,6 +94,9 @@ public static class Options { public static final String excludesAnnotation = "excludesAnnotation"; public static final String methodsAsFunctionsEnabled = "methodsAsFunctionsEnabled"; public static final String constructorsAsFunctionsEnabled = "constructorsAsFunctionsEnabled"; + public static final String instanceFieldsAsEnumEnabled = "instanceFieldsAsEnumEnabled"; + public static final String instanceFieldsAsFunctionsEnabled = "instanceFieldsAsFunctionsEnabled"; + public static final String instanceFieldsAsTupleEnabled = "instanceFieldsAsTupleEnabled"; } public Map options() { return processingEnv.getOptions(); } @@ -99,18 +105,21 @@ protected boolean enabledByDefault() { return true; } - public boolean enabled() { return Boolean.parseBoolean(findOption(Options.enabled, Boolean.toString(enabledByDefault()))); } - public Pattern includesRegex() { return Pattern.compile(findOption(Options.includesRegex, ".*")); } - public Pattern excludesRegex() { return Pattern.compile(findOption(Options.excludesRegex, ".*_")); } - public boolean onlyPublicMembers() { return Boolean.parseBoolean(findOption(Options.onlyPublicMembers, "false")); } - public boolean includePrivateMembers() { return Boolean.parseBoolean(findOption(Options.includePrivateMembers, "false")); } - public String generatedClassNamePattern() { return findOption(Options.generatedClassNamePattern, "{}_"); } - public String generatedPackagePattern() { return findOption(Options.generatedPackagePattern, "{}"); } - public String includesAnnotation() { return findOption(Options.includesAnnotation, ""); } - public String excludesAnnotation() { return findOption(Options.excludesAnnotation, mkString(",", newList("javax.annotation.processing.Generated", "javax.annotation.Generated", "javax.persistence.Entity", "javax.persistence.MappedSuperclass", "javax.persistence.Embeddable", NoMetadataGeneration.class.getName()))); } - public Pattern extendClassNamePattern() { return Pattern.compile(""); } - public boolean methodsAsFunctionsEnabled(){ return Boolean.parseBoolean(findOption(Options.methodsAsFunctionsEnabled, "true")); } - public boolean constructorsAsFunctionsEnabled(){ return Boolean.parseBoolean(findOption(Options.constructorsAsFunctionsEnabled, "true")); } + public boolean enabled() { return Boolean.parseBoolean(findOption(Options.enabled, Boolean.toString(enabledByDefault()))); } + public Pattern includesRegex() { return Pattern.compile(findOption(Options.includesRegex, ".*")); } + public Pattern excludesRegex() { return Pattern.compile(findOption(Options.excludesRegex, ".*_")); } + public boolean onlyPublicMembers() { return Boolean.parseBoolean(findOption(Options.onlyPublicMembers, "false")); } + public boolean includePrivateMembers() { return Boolean.parseBoolean(findOption(Options.includePrivateMembers, "false")); } + public String generatedClassNamePattern() { return findOption(Options.generatedClassNamePattern, "{}_"); } + public String generatedPackagePattern() { return findOption(Options.generatedPackagePattern, "{}"); } + public String includesAnnotation() { return findOption(Options.includesAnnotation, ""); } + public String excludesAnnotation() { return findOption(Options.excludesAnnotation, mkString(",", newList("javax.annotation.processing.Generated", "javax.annotation.Generated", "javax.persistence.Entity", "javax.persistence.MappedSuperclass", "javax.persistence.Embeddable", NoMetadataGeneration.class.getName()))); } + public Pattern extendClassNamePattern() { return Pattern.compile(""); } + public boolean methodsAsFunctionsEnabled() { return Boolean.parseBoolean(findOption(Options.methodsAsFunctionsEnabled, "true")); } + public boolean constructorsAsFunctionsEnabled() { return Boolean.parseBoolean(findOption(Options.constructorsAsFunctionsEnabled, "true")); } + public boolean instanceFieldsAsEnumEnabled() { return Boolean.parseBoolean(findOption(Options.instanceFieldsAsEnumEnabled, "true")); } + public boolean instanceFieldsAsFunctionsEnabled() { return Boolean.parseBoolean(findOption(Options.instanceFieldsAsFunctionsEnabled, "true")); } + public boolean instanceFieldsAsTupleEnabled() { return Boolean.parseBoolean(findOption(Options.instanceFieldsAsTupleEnabled, "true")); } public String findOption(String option, String defaultIfNotFound) { return find(getClass().getSimpleName() + "." + option, options()).getOrElse(defaultIfNotFound); @@ -169,6 +178,9 @@ public OPTIONS generatorOptions() { final String generatedClassNamePattern = CommonMetadataProcessor.this.generatedClassNamePattern(); final boolean methodsAsFunctionsEnabled = CommonMetadataProcessor.this.methodsAsFunctionsEnabled(); final boolean constructorsAsFunctionsEnabled = CommonMetadataProcessor.this.constructorsAsFunctionsEnabled(); + final boolean instanceFieldsAsEnumEnabled = CommonMetadataProcessor.this.instanceFieldsAsEnumEnabled(); + final boolean instanceFieldsAsFunctionsEnabled = CommonMetadataProcessor.this.instanceFieldsAsFunctionsEnabled(); + final boolean instanceFieldsAsTupleEnabled = CommonMetadataProcessor.this.instanceFieldsAsTupleEnabled(); return (OPTIONS) new CombinedGeneratorOptions() { public boolean onlyPublicMembers() { return onlyPublicMembers; @@ -192,6 +204,18 @@ public boolean methodsAsFunctionsEnabled() { public boolean constructorsAsFunctionsEnabled() { return constructorsAsFunctionsEnabled; } + @Override + public boolean instanceFieldsAsEnumEnabled() { + return instanceFieldsAsEnumEnabled; + } + @Override + public boolean instanceFieldsAsFunctionsEnabled() { + return instanceFieldsAsFunctionsEnabled; + } + @Override + public boolean instanceFieldsAsTupleEnabled() { + return instanceFieldsAsTupleEnabled; + } }; } @@ -272,14 +296,17 @@ public boolean doProcess(RoundEnvironment roundEnv) { } List, List>> nestedData = newList(map(nestedDataProducer, filter(Predicate.of(Function.constant(true)), nestedToProcess))); long time3 = System.nanoTime(); - Iterable content = map(padding, concat(flatMap(Helpers.>right(), elemData), flatMap(Helpers.>right(), nestedData))); + List content = newList(map(padding, concat(flatMap(Helpers.>right(), elemData), flatMap(Helpers.>right(), nestedData)))); String genPackage = genPackagePat.replace("{}", getPackageName(element)); String genClassName = genClassNamePat.replace("{}", element.getSimpleName().toString()); String superclassName = removeGenericPart.apply(element.getSuperclass().toString()); Option extendedClassName = extendClassNamePattern.matcher(superclassName).matches() ? Some(genClassNamePat.replace("{}", superclassName)) : Option.None(); long time4 = System.nanoTime(); - ClassFileWriter.writeClassFile(genPackage, genClassName, extendedClassName, content, clazz, filer, element, Option.of(element.getAnnotation(SuppressWarnings.class)), element.getAnnotation(Deprecated.class) != null); + if (!content.isEmpty() || Helpers.isAbstract(element)) { + // always produce metaclass for abstract classes in case they are inherited + ClassFileWriter.writeClassFile(genPackage, genClassName, extendedClassName, content, clazz, filer, element, Option.of(element.getAnnotation(SuppressWarnings.class)), element.getAnnotation(Deprecated.class) != null); + } generation += time2 - time; nestedGeneration += time3 - time2; diff --git a/src/main/java/fi/solita/utils/meta/ForceMetadataGeneration.java b/src/main/java/fi/solita/utils/meta/ForceMetadataGeneration.java index daea9eb..f163d74 100644 --- a/src/main/java/fi/solita/utils/meta/ForceMetadataGeneration.java +++ b/src/main/java/fi/solita/utils/meta/ForceMetadataGeneration.java @@ -13,4 +13,7 @@ public @interface ForceMetadataGeneration { boolean constructorsAsFunctions() default false; boolean methodsAsFunctions() default false; + boolean instanceFieldsAsEnum() default false; + boolean instanceFieldsAsFunctions() default false; + boolean instanceFieldsAsTuple() default false; } diff --git a/src/main/java/fi/solita/utils/meta/Helpers.java b/src/main/java/fi/solita/utils/meta/Helpers.java index a696f24..fcfd56b 100644 --- a/src/main/java/fi/solita/utils/meta/Helpers.java +++ b/src/main/java/fi/solita/utils/meta/Helpers.java @@ -303,11 +303,19 @@ public String visitPackage(PackageElement e, Object p) { } }; - public static final Function1> element2Fields = new Transformer>() { + public static final Function1> element2Fields = new Transformer>() { @SuppressWarnings("unchecked") @Override - public Iterable transform(Element source) { - return (Iterable) filter(fields, Workaround.getEnclosedElementsDeclarationOrder(source)); + public Iterable transform(Element source) { + return (Iterable) filter(fields, Workaround.getEnclosedElementsDeclarationOrder(source)); + } + }; + + public static final Function1> element2RecordComponents = new Transformer>() { + @SuppressWarnings("unchecked") + @Override + public Iterable transform(Element source) { + return (Iterable) filter(recordComponents, Workaround.getEnclosedElementsDeclarationOrder(source)); } }; @@ -370,6 +378,13 @@ public boolean accept(Element candidate) { } }; + public static final Predicate recordComponents = new Predicate() { + @Override + public boolean accept(Element candidate) { + return candidate.getKind().name().equals("RECORD_COMPONENT"); + } + }; + public static final Predicate classes = new Predicate() { @Override public boolean accept(Element candidate) { @@ -477,6 +492,10 @@ public static final boolean isFinal(Element e) { return e.getModifiers().contains(Modifier.FINAL); } + public static final boolean isAbstract(Element e) { + return e.getModifiers().contains(Modifier.ABSTRACT); + } + public static final boolean returnsVoid(ExecutableElement method) { return method.getReturnType().getKind() == TypeKind.VOID; } @@ -765,6 +784,7 @@ private boolean acc(final Element e, final Set visited) { Iterable constructorAnnotations; Iterable methodAnnotations; Iterable fieldAnnotations; + Iterable recordComponentAnnotations; if (includeNested) { for (TypeElement n: element2NestedClasses.apply(e)) { if (acc(n, visited)) { @@ -782,15 +802,21 @@ public List transform(ExecutableElement source) { public List transform(ExecutableElement source) { return source.getAnnotationMirrors(); }}, element2Methods.apply(e)); - fieldAnnotations = flatMap(new Transformer>() { + fieldAnnotations = flatMap(new Transformer>() { @Override - public List transform(VariableElement source) { + public List transform(Element source) { return source.getAnnotationMirrors(); }}, element2Fields.apply(e)); + recordComponentAnnotations = flatMap(new Transformer>() { + @Override + public List transform(Element source) { + return source.getAnnotationMirrors(); + }}, element2RecordComponents.apply(e)); } else { constructorAnnotations = Collections.emptyList(); methodAnnotations = Collections.emptyList(); fieldAnnotations = Collections.emptyList(); + recordComponentAnnotations = Collections.emptyList(); } return exists(new Predicate() { @Override @@ -798,7 +824,7 @@ public boolean accept(AnnotationMirror m) { Element elem = m.getAnnotationType().asElement(); return className.contains(qualifiedName.apply(elem)) || !elem.equals(e) && acc(elem, visited); } - }, concat(e.getAnnotationMirrors(), constructorAnnotations, methodAnnotations, fieldAnnotations)); + }, concat(e.getAnnotationMirrors(), constructorAnnotations, methodAnnotations, fieldAnnotations, recordComponentAnnotations)); } }; } diff --git a/src/main/java/fi/solita/utils/meta/generators/ConstructorsAsFunctions.java b/src/main/java/fi/solita/utils/meta/generators/ConstructorsAsFunctions.java index 59a8afe..f930b16 100644 --- a/src/main/java/fi/solita/utils/meta/generators/ConstructorsAsFunctions.java +++ b/src/main/java/fi/solita/utils/meta/generators/ConstructorsAsFunctions.java @@ -49,7 +49,6 @@ import fi.solita.utils.functional.Apply; import fi.solita.utils.functional.Function1; import fi.solita.utils.functional.Function3; -import fi.solita.utils.functional.Option; import fi.solita.utils.meta.ForceMetadataGeneration; import fi.solita.utils.meta.Helpers; diff --git a/src/main/java/fi/solita/utils/meta/generators/Content.java b/src/main/java/fi/solita/utils/meta/generators/Content.java index e70183c..0220388 100644 --- a/src/main/java/fi/solita/utils/meta/generators/Content.java +++ b/src/main/java/fi/solita/utils/meta/generators/Content.java @@ -152,7 +152,7 @@ public Pair,List> apply(CommonMetadataProcessor.CombinedGener Iterable generatorTimesForContent = map(Helpers.left(), elemData); Iterable> generatorTimesForNestedClasses = map(Helpers.>left(), nestedData); - Iterable elemContents = flatMap(Helpers.>right(), elemData); + List elemContents = newList(flatMap(Helpers.>right(), elemData)); Iterable nestedContents = flatMap(Helpers.>right(), nestedData); List totalTimesPerGenerator = newList(map(Helpers.iterableSum, transpose(cons(generatorTimesForContent, generatorTimesForNestedClasses)))); @@ -172,7 +172,7 @@ public Pair,List> apply(CommonMetadataProcessor.CombinedGener elemContents, map(padding, nestedContents), Some("}"))); - return Pair.of(totalTimesPerGenerator, allContents); + return Pair.of(totalTimesPerGenerator, !Helpers.isAbstract(source) && elemContents.isEmpty() && nestedData.isEmpty() ? Collections.emptyList() : allContents); } }; } diff --git a/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsEnum.java b/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsEnum.java index d840773..330a48a 100644 --- a/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsEnum.java +++ b/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsEnum.java @@ -1,11 +1,5 @@ package fi.solita.utils.meta.generators; -import static fi.solita.utils.meta.Helpers.element2Fields; -import static fi.solita.utils.meta.Helpers.padding; -import static fi.solita.utils.meta.Helpers.privateElement; -import static fi.solita.utils.meta.Helpers.publicElement; -import static fi.solita.utils.meta.Helpers.simpleName; -import static fi.solita.utils.meta.Helpers.staticElements; import static fi.solita.utils.functional.Collections.emptyList; import static fi.solita.utils.functional.Collections.newList; import static fi.solita.utils.functional.Functional.filter; @@ -14,12 +8,20 @@ import static fi.solita.utils.functional.Option.Some; import static fi.solita.utils.functional.Predicates.not; import static fi.solita.utils.functional.Transformers.append; +import static fi.solita.utils.meta.Helpers.element2Fields; +import static fi.solita.utils.meta.Helpers.padding; +import static fi.solita.utils.meta.Helpers.privateElement; +import static fi.solita.utils.meta.Helpers.publicElement; +import static fi.solita.utils.meta.Helpers.simpleName; +import static fi.solita.utils.meta.Helpers.staticElements; import java.util.List; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; + +import fi.solita.utils.meta.ForceMetadataGeneration; public class InstanceFieldsAsEnum extends Generator{ @@ -28,18 +30,23 @@ public class InstanceFieldsAsEnum extends Generator apply(ProcessingEnvironment processingEnv, Options options, TypeElement source) { - Iterable elements = element2Fields.apply(source); + if (!options.instanceFieldsAsEnumEnabled() && (source.getAnnotation(ForceMetadataGeneration.class) == null || !source.getAnnotation(ForceMetadataGeneration.class).instanceFieldsAsEnum())) { + return emptyList(); + } + + Iterable elements = element2Fields.apply(source); if (options.onlyPublicMembers()) { elements = filter(publicElement, elements); } else if (!options.includePrivateMembers()) { elements = filter(not(privateElement), elements); } - List fieldsToInclude = newList(filter(not(staticElements), elements)); + List fieldsToInclude = newList(filter(not(staticElements), elements)); if (fieldsToInclude.isEmpty()) { return emptyList(); } diff --git a/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsFunctions.java b/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsFunctions.java index 8378447..db4f2c3 100644 --- a/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsFunctions.java +++ b/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsFunctions.java @@ -1,5 +1,18 @@ package fi.solita.utils.meta.generators; +import static fi.solita.utils.functional.Collections.emptyList; +import static fi.solita.utils.functional.Collections.newList; +import static fi.solita.utils.functional.Functional.filter; +import static fi.solita.utils.functional.Functional.flatMap; +import static fi.solita.utils.functional.Functional.isEmpty; +import static fi.solita.utils.functional.Functional.map; +import static fi.solita.utils.functional.Functional.mkString; +import static fi.solita.utils.functional.Functional.subtract; +import static fi.solita.utils.functional.Functional.zip; +import static fi.solita.utils.functional.FunctionalA.concat; +import static fi.solita.utils.functional.FunctionalA.contains; +import static fi.solita.utils.functional.Option.Some; +import static fi.solita.utils.functional.Predicates.not; import static fi.solita.utils.meta.Helpers.element2Fields; import static fi.solita.utils.meta.Helpers.elementGenericQualifiedName; import static fi.solita.utils.meta.Helpers.hasNonQmarkGenerics; @@ -19,28 +32,15 @@ import static fi.solita.utils.meta.generators.Content.EmptyLine; import static fi.solita.utils.meta.generators.Content.None; import static fi.solita.utils.meta.generators.Content.catchBlock; -import static fi.solita.utils.functional.Collections.newList; -import static fi.solita.utils.functional.Functional.contains; -import static fi.solita.utils.functional.Functional.filter; -import static fi.solita.utils.functional.Functional.flatMap; -import static fi.solita.utils.functional.Functional.isEmpty; -import static fi.solita.utils.functional.Functional.map; -import static fi.solita.utils.functional.Functional.mkString; -import static fi.solita.utils.functional.Functional.subtract; -import static fi.solita.utils.functional.Functional.zip; -import static fi.solita.utils.functional.FunctionalA.concat; -import static fi.solita.utils.functional.Option.Some; -import static fi.solita.utils.functional.Predicates.not; import java.util.List; import java.util.regex.Pattern; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeKind; -import fi.solita.utils.meta.Helpers; import fi.solita.utils.functional.Apply; import fi.solita.utils.functional.Function1; import fi.solita.utils.functional.Function3; @@ -48,6 +48,8 @@ import fi.solita.utils.functional.Predicate; import fi.solita.utils.functional.Transformer; import fi.solita.utils.functional.Tuple2; +import fi.solita.utils.meta.ForceMetadataGeneration; +import fi.solita.utils.meta.Helpers; public class InstanceFieldsAsFunctions extends Generator { @@ -64,11 +66,16 @@ public static interface Options extends GeneratorOptions { boolean makeFieldsPublic(); boolean onlyPublicMembers(); boolean includePrivateMembers(); + boolean instanceFieldsAsFunctionsEnabled(); } @Override public Iterable apply(ProcessingEnvironment processingEnv, Options options, TypeElement source) { - Iterable elements = element2Fields.apply(source); + if (!options.instanceFieldsAsFunctionsEnabled() && (source.getAnnotation(ForceMetadataGeneration.class) == null || !source.getAnnotation(ForceMetadataGeneration.class).instanceFieldsAsFunctions())) { + return emptyList(); + } + + Iterable elements = element2Fields.apply(source); if (options.onlyPublicMembers()) { elements = filter(publicElement, elements); } else if (!options.includePrivateMembers()) { @@ -86,7 +93,7 @@ public Pattern transform(String obj) { }; // this hack is a way to share most of the code with other generators - static abstract class F extends Function3> { + static abstract class F extends Function3> { String enclosingElementQualifiedNameImported; String relevantTypeParamsString; List relevantTypeParamsWithoutConstraints; @@ -96,7 +103,7 @@ static abstract class F extends Function3 apply(Options options, Helpers.EnvDependent helper, VariableElement field) { + public Iterable apply(Options options, Helpers.EnvDependent helper, Element field) { TypeElement enclosingElement = (TypeElement) field.getEnclosingElement(); String enclosingElementQualifiedName = qualifiedName.apply(enclosingElement); enclosingElementQualifiedNameImported = importTypes(enclosingElementQualifiedName); diff --git a/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsTuple.java b/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsTuple.java index ff54fcd..7460f11 100644 --- a/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsTuple.java +++ b/src/main/java/fi/solita/utils/meta/generators/InstanceFieldsAsTuple.java @@ -14,7 +14,7 @@ import static fi.solita.utils.functional.Functional.isEmpty; import static fi.solita.utils.functional.Functional.map; import static fi.solita.utils.functional.Functional.mkString; -import static fi.solita.utils.functional.FunctionalA.concat; +import static fi.solita.utils.functional.Functional.concat; import static fi.solita.utils.functional.Option.Some; import static fi.solita.utils.functional.Predicates.not; @@ -22,9 +22,10 @@ import java.util.regex.Pattern; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import javax.lang.model.element.VariableElement; +import fi.solita.utils.meta.ForceMetadataGeneration; import fi.solita.utils.meta.Helpers; import fi.solita.utils.meta.Helpers.EnvDependent; import fi.solita.utils.functional.Apply; @@ -46,19 +47,24 @@ public static interface Options extends GeneratorOptions { String generatedPackagePattern(); String generatedClassNamePattern(); + boolean instanceFieldsAsTupleEnabled(); } @Override public Iterable apply(ProcessingEnvironment processingEnv, final Options options, final TypeElement enclosingElement) { - Iterable elements = Helpers.element2Fields.apply(enclosingElement); + if (!options.instanceFieldsAsTupleEnabled() && (enclosingElement.getAnnotation(ForceMetadataGeneration.class) == null || !enclosingElement.getAnnotation(ForceMetadataGeneration.class).instanceFieldsAsTuple())) { + return emptyList(); + } + + Iterable elements = Helpers.element2Fields.apply(enclosingElement); if (options.onlyPublicMembers()) { elements = filter(publicElement, elements); } else if (!options.includePrivateMembers()) { elements = filter(not(privateElement), elements); } - List fieldsToInclude = newList(filter(not(staticElements), elements)); - if (fieldsToInclude.size() > Tuple.class.getDeclaredClasses().length) { + List fieldsToInclude = newList(filter(not(staticElements), elements)); + if (fieldsToInclude.size() > Tuple.class.getDeclaredClasses().length || fieldsToInclude.isEmpty()) { return emptyList(); } @@ -72,9 +78,9 @@ public Iterable apply(ProcessingEnvironment processingEnv, final Options final EnvDependent helper = new Helpers.EnvDependent(processingEnv); - List> fieldData = newList(map(new Transformer>() { + List> fieldData = newList(map(new Transformer>() { @Override - public Tuple3 transform(VariableElement field) { + public Tuple3 transform(Element field) { f.apply((fi.solita.utils.meta.generators.InstanceFieldsAsFunctions.Options) options, helper, field); String relevantTypeParamsString = isEmpty(f.relevantTypeParamsWithoutConstraints) ? "" : "<" + mkString(", ", f.relevantTypeParamsWithoutConstraints) + ">"; diff --git a/src/main/java/fi/solita/utils/meta/generators/MethodsAsFunctions.java b/src/main/java/fi/solita/utils/meta/generators/MethodsAsFunctions.java index 4a1b400..9bd231b 100644 --- a/src/main/java/fi/solita/utils/meta/generators/MethodsAsFunctions.java +++ b/src/main/java/fi/solita/utils/meta/generators/MethodsAsFunctions.java @@ -56,6 +56,7 @@ import java.util.Set; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.TypeElement; import javax.lang.model.element.TypeParameterElement; @@ -102,7 +103,7 @@ public Iterable apply(ProcessingEnvironment processingEnv, Options optio elements = filter(not(privateElement), elements); } - Iterable processedFields = element2Fields.apply(source); + Iterable processedFields = element2Fields.apply(source); if (options.onlyPublicMembers()) { processedFields = filter(publicElement, processedFields); } else if (!options.includePrivateMembers()) {