branch feature/3745 created (now dd8b076)
This is an automated email from the git hooks/post-receive script. New change to branch feature/3745 in repository eugene. See http://git.nuiton.org/eugene.git at dd8b076 Pouvoir générer des méthodes utiles (predicat, function) sur des beans (refs #3745) This branch includes the following new commits: new dd8b076 Pouvoir générer des méthodes utiles (predicat, function) sur des beans (refs #3745) The 1 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: commit dd8b0765c2d755cff6d42a1d839cf77da4ce279e Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Aug 14 15:36:37 2015 +0200 Pouvoir générer des méthodes utiles (predicat, function) sur des beans (refs #3745) -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/3745 in repository eugene. See http://git.nuiton.org/eugene.git commit dd8b0765c2d755cff6d42a1d839cf77da4ce279e Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Aug 14 15:36:37 2015 +0200 Pouvoir générer des méthodes utiles (predicat, function) sur des beans (refs #3745) --- .../nuiton/eugene/java/JavaTemplatesTagValues.java | 65 ++++++++ .../SimpleJavaBeanWithNoInterfaceTransformer.java | 176 ++++++++++++++++++++- 2 files changed, 239 insertions(+), 2 deletions(-) diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java index 77ad643..cf8b1e9 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/JavaTemplatesTagValues.java @@ -516,6 +516,36 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_SUFFIX = "simpleBeanWithNoInterfaceDefaultsClassNameSuffix"; /** + * To generate or not guava predicates on each property of the bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #isSimpleBeanWithNoInterfaceGeneratePredicates(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + defaultValue = "true", + documentation = "To generate or not guava predicates on propertyes on beans.\n" + + "(only effective with simple bean with no interface generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_PREDICATES = "simpleBeanWithNoInterfaceGeneratePredicates"; + + /** + * To generate or not guava functions on each property of the bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #isSimpleBeanWithNoInterfaceGenerateFunctions(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + defaultValue = "true", + documentation = "To generate or not guava predicates on propertyes on beans.\n" + + "(only effective with simple bean with no interface generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS= "simpleBeanWithNoInterfaceGenerateFunctions"; + + /** * Obtain the value of the {@link #TAG_GENERATE_PROPERTY_CHANGE_SUPPORT} tag value on the given model, package or classifier. * * It will first look on the model, then and package and then in the given classifier. @@ -880,4 +910,39 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { return value; } + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_PREDICATES} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_PREDICATES + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceGeneratePredicates(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + boolean value = findBooleanTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_PREDICATES, classifier, aPackage, model); + return value; + } +/** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * <strong>If not filled, then use default {@code s} value.</strong> + * + * @param classifier classifier to seek + * @param model model to seek + * @return the none empty value of the found tag value or {@code null} if not found nor empty. + * @see #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceGenerateFunctions(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + boolean value = findBooleanTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_FUNCTIONS, classifier, aPackage, model); + return value; + } + } diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java index 94a8b3f..b904c55 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java @@ -25,6 +25,11 @@ package org.nuiton.eugene.java; /*{generator option: parentheses = false}*/ /*{generator option: writeString = +}*/ +import com.google.common.base.Function; +import com.google.common.base.Predicate; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Maps; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.logging.Log; @@ -40,6 +45,7 @@ import org.nuiton.util.beans.BinderFactory; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Objects; /** * Generates a java bean and a utility class around it. This transformer acts like {@link SimpleJavaBeanTransformer} @@ -270,6 +276,9 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr if (!isInClassPath(packageName, abstractClassName)) { + boolean generatePredicates = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGeneratePredicates(aClass, aPackage, model); + boolean generateFunctions = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateFunctions(aClass, aPackage, model); + // generate abstract defaults class // try to find a super class by tag-value @@ -324,7 +333,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr setOperationBody(operation, "" /*{ Class<BeanType> sourceType = typeOf<%=typeName%>(); - Binder<BeanType,BeanType> binder = BinderFactory.newBinder(sourceType); + Binder<BeanType, BeanType> binder = BinderFactory.newBinder(sourceType); BeanType result = new<%=typeName%>(source, binder); return result; }*/ @@ -359,7 +368,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr setOperationBody(operation, "" /*{ Class<BeanType> sourceType = typeOf<%=typeName%>(); - Binder<BeanType,BeanType> binder = BinderFactory.newBinder(sourceType); + Binder<BeanType, BeanType> binder = BinderFactory.newBinder(sourceType); binder.copy(source, target); }*/ ); @@ -379,7 +388,170 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr binder.copy(source, target); }*/ ); + + if (generatePredicates) { + generatePredicates(aClass, output, typeName); + } + + if (generateFunctions) { + generateFunctions(aClass, output, typeName); + } + } + } + + protected void generatePredicates(ObjectModelClass input, ObjectModelClass output, String typeName) { + + List<ObjectModelAttribute> properties = getProperties(input); + + if (!properties.isEmpty()) { + addImport(output, Predicate.class); + addImport(output, Objects.class); + addImport(output, Iterable.class); + addImport(output, Iterables.class); + } + + for (ObjectModelAttribute attribute : properties) { + + boolean multiple = JavaGeneratorUtil.isNMultiplicity(attribute); + + if (multiple) { + continue; + } + + String attrName = getAttributeName(attribute); + String attrType = getAttributeType(attribute); + + String simpleType = JavaGeneratorUtil.getSimpleName(attrType); + + String capitalizeAttrName = JavaGeneratorUtil.capitalizeJavaBeanPropertyName(attrName); + String newPreficateMethodName= "new" + capitalizeAttrName + "Predicate"; + ObjectModelOperation operation = addOperation( + output, + newPreficateMethodName, + "<BeanType extends " + typeName + "> Predicate<BeanType>", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, simpleType, attrName); + + String getterName = getGetterName(attrName, attribute); + setOperationBody(operation, "" + /*{ + final <%=simpleType%> $tmp = <%=attrName%>; + return new Predicate<BeanType>() { + + @Override + public boolean apply(BeanType input) { + return Objects.equals($tmp, input.<%=getterName%>()); + } + }; + + }*/ + ); + + operation = addOperation( + output, + "filterBy" + capitalizeAttrName, + "<BeanType extends " + typeName + "> Iterable<BeanType>", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "Iterable<BeanType>", "source"); + addParameter(operation, simpleType, attrName); + setOperationBody(operation, "" + /*{ + return Iterables.filter(source, <%=newPreficateMethodName%>(<%=attrName%>)); + }*/ + ); + } + + } + + protected void generateFunctions(ObjectModelClass input, ObjectModelClass output, String typeName) { + + List<ObjectModelAttribute> properties = getProperties(input); + if (!properties.isEmpty()) { + addImport(output, Function.class); + addImport(output, Objects.class); + addImport(output, ImmutableMap.class); + addImport(output, Iterable.class); + addImport(output, Maps.class); + } + + for (ObjectModelAttribute attribute : properties) { + + boolean multiple = JavaGeneratorUtil.isNMultiplicity(attribute); + + if (multiple) { + continue; + } + + String attrName = getAttributeName(attribute); + String attrType = getAttributeType(attribute); + + String simpleType = JavaGeneratorUtil.getSimpleName(attrType); + String capitalizeAttrName = JavaGeneratorUtil.capitalizeJavaBeanPropertyName(attrName); + String newFunctionMethodName= "new" + capitalizeAttrName + "Function"; + String newFunctionTypeName= "Function<BeanType, " + simpleType + ">"; + + ObjectModelOperation operation = addOperation( + output, + newFunctionMethodName, + "<BeanType extends " + typeName + "> "+newFunctionTypeName, + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + + String getterName = getGetterName(attrName, attribute); + setOperationBody(operation, "" + /*{ + return new <%=newFunctionTypeName%>() { + + @Override + public <%=simpleType%> apply(BeanType input) { + return input.<%=getterName%>(); + } + }; + + }*/ + ); + + String getFunctionFieldName = JavaGeneratorUtil.convertVariableNameToConstantName("get" + capitalizeAttrName); + addAttribute( + output, + getFunctionFieldName, + "Function<" + typeName + ", " + simpleType + ">", + newFunctionMethodName + "()", + ObjectModelJavaModifier.FINAL, + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PROTECTED + ); + + operation = addOperation( + output, + "uniqueIndexBy" + capitalizeAttrName, + "<BeanType extends " + typeName + "> ImmutableMap<" + simpleType + ", BeanType>", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "Iterable<BeanType>", "source"); + setOperationBody(operation, "" + /*{ + return Maps.uniqueIndex(source, <%=getFunctionFieldName%>); + }*/ + ); + } + + } + + private String getGetterName(String attrName, ObjectModelAttribute attribute) { + boolean booleanProperty = JavaGeneratorUtil.isBooleanPrimitive(attribute); + String methodPrefix = JavaGeneratorUtil.OPERATION_GETTER_DEFAULT_PREFIX; + if (booleanProperty) { + methodPrefix = JavaGeneratorUtil.OPERATION_GETTER_BOOLEAN_PREFIX; } + String getterName = getJavaBeanMethodName(methodPrefix, attrName); + return getterName; } protected Collection<ObjectModelOperation> getPublicOperations(ObjectModelClass clazz) { -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
participants (1)
-
nuiton.org scm