branch develop updated (39952d8 -> 81fb309)
This is an automated email from the git hooks/post-receive script. New change to branch develop in repository eugene. See http://git.nuiton.org/eugene.git from 39952d8 Can't use prefix and suffix in simpleBeanWithNoInterface generator (termine #3746) Merge branch 'feature/3746' into develop new 81fb309 Improve some generation code 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 81fb30993a1e6da58d9815ae3dd7a1c0ed6cb06d Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Aug 14 22:25:31 2015 +0200 Improve some generation code Summary of changes: .../eugene/java/AbstractJavaBeanTransformer.java | 36 ++ .../eugene/java/SimpleJavaBeanTransformer.java | 13 - .../SimpleJavaBeanWithNoInterfaceTransformer.java | 504 ++++++++++----------- .../main/java/org/nuiton/eugene/GeneratorUtil.java | 2 +- 4 files changed, 268 insertions(+), 287 deletions(-) -- 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 develop in repository eugene. See http://git.nuiton.org/eugene.git commit 81fb30993a1e6da58d9815ae3dd7a1c0ed6cb06d Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Aug 14 22:25:31 2015 +0200 Improve some generation code --- .../eugene/java/AbstractJavaBeanTransformer.java | 36 ++ .../eugene/java/SimpleJavaBeanTransformer.java | 13 - .../SimpleJavaBeanWithNoInterfaceTransformer.java | 504 ++++++++++----------- .../main/java/org/nuiton/eugene/GeneratorUtil.java | 2 +- 4 files changed, 268 insertions(+), 287 deletions(-) diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java index 6c6c053..4f35699 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/AbstractJavaBeanTransformer.java @@ -64,6 +64,12 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer return javaTemplatesTagValues; } + protected boolean notFoundInClassPath(ObjectModelClass input, String className) { + String fqn = input.getPackageName() + "." + className; + boolean inClassPath = isInClassPath(fqn); + return !inClassPath; + } + protected void createPropertyConstant(ObjectModelClassifier output, ObjectModelAttribute attr, String prefix, @@ -795,4 +801,34 @@ public abstract class AbstractJavaBeanTransformer extends ObjectModelTransformer createGetChildMethod(output); } } + + protected String wrapPrimitiveType(String attrType) { + if (JavaGeneratorUtil.isPrimitiveType(attrType)) { + attrType = JavaGeneratorUtil.getPrimitiveWrapType(attrType); + } + return attrType; + } + + protected String getGetterName(ObjectModelAttribute attribute, String attrName) { + 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 String generateName(String prefix, String name, String suffix) { + StringBuilder sb = new StringBuilder(); + if (StringUtils.isNotEmpty(prefix)) { + sb.append(prefix); + } + sb.append(name); + if (StringUtils.isNotEmpty(suffix)) { + sb.append(suffix); + } + return sb.toString(); + } + } diff --git a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java index bca0931..886ebce 100644 --- a/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanTransformer.java @@ -614,17 +614,4 @@ public class SimpleJavaBeanTransformer extends AbstractJavaBeanTransformer { ); } - protected String generateName(String prefix, - String name, - String suffix) { - StringBuilder sb = new StringBuilder(); - if (StringUtils.isNotEmpty(prefix)) { - sb.append(prefix); - } - sb.append(name); - if (StringUtils.isNotEmpty(suffix)) { - sb.append(suffix); - } - return sb.toString(); - } } 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 e051166..f05655f 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 @@ -28,12 +28,14 @@ package org.nuiton.eugene.java; import com.google.common.base.Function; import com.google.common.base.Predicate; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; 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; import org.apache.commons.logging.LogFactory; +import org.nuiton.eugene.models.object.ObjectModel; import org.nuiton.eugene.models.object.ObjectModelAttribute; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelJavaModifier; @@ -67,83 +69,106 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr /** Logger. */ private static final Log log = LogFactory.getLog(SimpleJavaBeanWithNoInterfaceTransformer.class); + ImmutableMap<ObjectModelClass, String> beanNameTranslation; + + ImmutableMap<ObjectModelClass, String> beanDefaultsNameTranslation; + + ImmutableSet<ObjectModelClass> beanClasses; + + ImmutableSet<ObjectModelClass> beanDefaultClasses; + @Override - public void transformFromClass(ObjectModelClass input) { + public void transformFromModel(ObjectModel model) { + super.transformFromModel(model); - ObjectModelPackage aPackage = getPackage(input); + ImmutableMap.Builder<ObjectModelClass, String> beanNameTranslationBuilder = new ImmutableMap.Builder<>(); + ImmutableMap.Builder<ObjectModelClass, String> beanDefaultsNameTranslationBuilder = new ImmutableMap.Builder<>(); + ImmutableSet.Builder<ObjectModelClass> beanClassesBuilder = new ImmutableSet.Builder<>(); + ImmutableSet.Builder<ObjectModelClass> beanDefaultClassesBuilder = new ImmutableSet.Builder<>(); - if (JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage)) { + JavaTemplatesTagValues javaTemplatesTagValues = getJavaTemplatesTagValues(); - String className = getBeanClassName(aPackage, input); - String abstractClassName = "Abstract" + className; - String defaultClassName = getBeanDefaultsClassName(aPackage, input); - String abstractDefaultClassName = "Abstract" + defaultClassName; + for (ObjectModelClass aClass : model.getClasses()) { - boolean generateDefaults = canGenerateBeanDefaults(aPackage, input); - boolean generateAbstractClass = canGenerateAbstractBean(input, abstractClassName); - boolean generateClass = canGenerateBean(input, className); + ObjectModelPackage aPackage = model.getPackage(aClass.getPackageName()); + if (JavaTemplatesStereoTypes.hasBeanStereotype(aClass, aPackage)) { - String prefix = getConstantPrefix(input); - setConstantPrefix(prefix); + beanClassesBuilder.add(aClass); - if (generateAbstractClass) { - generateAbstractBeanClass(aPackage, input, abstractClassName); - } + String classNamePrefix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(aClass, aPackage, model); + String classNameSuffix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(aClass, aPackage, model); - if (generateClass) { - generateBeanClass(input, className, abstractClassName); - } + String generateName = generateName(classNamePrefix, aClass.getName(), classNameSuffix); + beanNameTranslationBuilder.put(aClass, generateName); + + boolean canGenerateDefaults = javaTemplatesTagValues.isSimpleBeanWithNoInterfaceGenerateDefaults(aClass, aPackage, model); + + if (canGenerateDefaults) { + + beanDefaultClassesBuilder.add(aClass); + + String classDefaultsNamePrefix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(aClass, aPackage, model); + String classDefaultsNameSuffix = javaTemplatesTagValues.getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(aClass, aPackage, model); + + String generateDefaultsName = generateName(classDefaultsNamePrefix, aClass.getName(), classDefaultsNameSuffix); + beanDefaultsNameTranslationBuilder.put(aClass, generateDefaultsName); + + } - if (generateDefaults) { - generateBeanDefaults(aPackage, input, className, abstractDefaultClassName, defaultClassName); } } - } + beanClasses = beanClassesBuilder.build(); + beanDefaultClasses = beanDefaultClassesBuilder.build(); + beanNameTranslation = beanNameTranslationBuilder.build(); + beanDefaultsNameTranslation = beanDefaultsNameTranslationBuilder.build(); - protected boolean canGenerateAbstractBean(ObjectModelClass input, String className) { - String fqn = input.getPackageName() + "." + className; - boolean canGenerate = !isInClassPath(fqn); - return canGenerate; } - protected boolean canGenerateBean(ObjectModelClass input, String className) { - String fqn = input.getPackageName() + "." + className; - boolean canGenerate = !isInClassPath(fqn); + @Override + public void transformFromClass(ObjectModelClass input) { + + ObjectModelPackage aPackage = getPackage(input); + + if (beanClasses.contains(input)) { - if (canGenerate) { + String prefix = getConstantPrefix(input); + setConstantPrefix(prefix); + + String className = beanNameTranslation.get(input); + String abstractClassName = "Abstract" + className; - // check there is no operation on input - if (!input.getOperations().isEmpty()) { - canGenerate = false; -// throw new GeneratorException( -// "Can't generate a simple bean as class " + -// fqn + -// " contains so operations." + -// "\nUse instead the JavaBeanTransformer."); + boolean generateClass = input.getOperations().isEmpty() && notFoundInClassPath(input, className); + if (generateClass) { + generateBeanClass(input, className, abstractClassName); } - } - return canGenerate; - } - protected boolean canGenerateBeanDefaults(ObjectModelPackage aPackage, ObjectModelClass input) { + boolean generateAbstractClass = notFoundInClassPath(input, abstractClassName); + if (generateAbstractClass) { + generateAbstractBeanClass(aPackage, input, abstractClassName); + } + + boolean generateDefaults = beanDefaultClasses.contains(input); + if (generateDefaults) { - boolean withInput = input != null; + String defaultClassName = beanDefaultsNameTranslation.get(input); + String abstractDefaultClassName = "Abstract" + defaultClassName; - boolean canGenerate = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateDefaults(input, aPackage, model); + if (notFoundInClassPath(input, defaultClassName)) { - if (canGenerate) { + generateBeanDefaults(input, abstractDefaultClassName, defaultClassName); + } - if (withInput) { + if (notFoundInClassPath(input, defaultClassName)) { - // class is a bean - canGenerate = JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage); + generateAbstractBeanDefaults(aPackage, input, className, abstractDefaultClassName); + } } + } - return canGenerate; } protected ObjectModelClass generateBeanClass(ObjectModelClass input, @@ -180,13 +205,12 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr Collection<ObjectModelClass> superclasses = input.getSuperclasses(); if (CollectionUtils.isNotEmpty(superclasses)) { for (ObjectModelClass superclass : superclasses) { - if (JavaTemplatesStereoTypes.hasBeanStereotype(superclass, aPackage)) { - superClassIsBean = true; - superClass = superclass.getPackageName() + "." + getBeanClassName(aPackage, superclass); + superClassIsBean = beanClasses.contains(superclass); + if (superClassIsBean) { + superClass = beanNameTranslation.get(superclass); break; - } else { - superClass = superclass.getQualifiedName(); } + superClass = superclass.getQualifiedName(); } } @@ -224,7 +248,6 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr List<ObjectModelAttribute> properties = getProperties(input); boolean usePCS = getJavaTemplatesTagValues().isGeneratePropertyChangeSupport(input, aPackage, model); - boolean generateBooleanGetMethods = getEugeneTagValues().isGenerateBooleanGetMethods(input, aPackage, model); boolean generateNotEmptyCollections = getJavaTemplatesTagValues().isGenerateNotEmptyCollections(input, aPackage, model); @@ -244,213 +267,160 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr return output; } - protected void generateBeanDefaults(ObjectModelPackage aPackage, - ObjectModelClass aClass, - String typeName, - String abstractClassName, - String defaultClassName) { + protected void generateBeanDefaults(ObjectModelClass aClass, String abstractClassName, String defaultClassName) { - boolean generateDefault = canGenerateBeanDefaults(aPackage, aClass); + String packageName = aClass.getPackageName(); - if (!generateDefault) { - return; + ObjectModelClass output = createClass(defaultClassName, packageName); + setSuperClass(output, packageName + "." + abstractClassName); + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); } - String packageName = aClass.getPackageName(); -// String typeName = getBeanInterfaceName(aPackage, aClass); -// String typeBeanName = getBeanClassName(aPackage, aClass); + } - if (!isInClassPath(packageName, defaultClassName)) { + protected void generateAbstractBeanDefaults(ObjectModelPackage aPackage, + ObjectModelClass aClass, + String typeName, + String abstractClassName) { - // generate defaults class + ObjectModelClass output = createAbstractClass(abstractClassName, aPackage.getName()); + String superClassName = getAbstractDefaultsSuperClassName(aPackage, aClass); - ObjectModelClass output = createClass(defaultClassName, packageName); - setSuperClass(output, packageName + "." + abstractClassName); - if (log.isDebugEnabled()) { - log.debug("will generate " + output.getQualifiedName()); - } + if (StringUtils.isNotBlank(superClassName)) { + setSuperClass(output, superClassName); } - if (!isInClassPath(packageName, abstractClassName)) { - - boolean generatePredicates = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGeneratePredicates(aClass, aPackage, model); - boolean generateFunctions = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateFunctions(aClass, aPackage, model); - boolean generateContructors = !aClass.isAbstract(); - - String superClassName = null; - - // test if a super class has bean stereotype - boolean superClassIsBean = false; - Collection<ObjectModelClass> superclasses = aClass.getSuperclasses(); - if (CollectionUtils.isNotEmpty(superclasses)) { - for (ObjectModelClass superclass : superclasses) { - if (JavaTemplatesStereoTypes.hasBeanStereotype(superclass, aPackage)) { - superClassIsBean = true; - superClassName = superclass.getPackageName() + "." + getBeanDefaultsClassName(aPackage, superclass); - break; - } else { - superClassName = superclass.getQualifiedName(); - } - } - } - - if (!superClassIsBean) { - - // try to find a super class by tag-value - superClassName = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(aClass, aPackage, model); + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); + } - } + addImport(output, Binder.class); + addImport(output, BinderFactory.class); + + ObjectModelOperation operation = addOperation( + output, + "typeOf" + typeName, + "<BeanType extends " + typeName + "> Class<BeanType>", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + setOperationBody(operation, "" + /*{ + return (Class<BeanType>) <%=typeName%>.class; + }*/ + ); - // generate abstract defaults class + boolean generateContructors = !aClass.isAbstract(); + if (generateContructors) { + generateAbstractBeanDefaultsConstructors(output, typeName); + } - ObjectModelClass output = createAbstractClass(abstractClassName, packageName); - if (StringUtils.isNotBlank(superClassName)) { - setSuperClass(output, superClassName); - } + generateAbstractBeanDefaultsCopyMethods(output, typeName); - if (log.isDebugEnabled()) { - log.debug("will generate " + output.getQualifiedName()); - } + boolean generatePredicates = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGeneratePredicates(aClass, aPackage, model); + if (generatePredicates) { + generateAbstractBeanDefaultsPredicates(aClass, output, typeName); + } - addImport(output, Binder.class); - addImport(output, BinderFactory.class); + boolean generateFunctions = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateFunctions(aClass, aPackage, model); + if (generateFunctions) { + generateAbstractBeanDefaultsFunctions(aClass, output, typeName); + } - ObjectModelOperation operation = addOperation( - output, - "typeOf" + typeName, - "<BeanType extends " + typeName + "> Class<BeanType>", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - setOperationBody(operation, "" - /*{ - return (Class<BeanType>) <%=typeName%>.class; - }*/ - ); + } - if (generateContructors) { + protected void generateAbstractBeanDefaultsConstructors(ObjectModelClass output, String typeName) { - operation = addOperation( - output, - "new" + typeName, - typeName, - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - setOperationBody(operation, "" + ObjectModelOperation operation = addOperation( + output, + "new" + typeName, + typeName, + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + setOperationBody(operation, "" /*{ return new <%=typeName%>(); }*/ - ); - - operation = addOperation( - output, - "new" + typeName, - "<BeanType extends " + typeName + "> BeanType", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - addParameter(operation, "BeanType", "source"); - setOperationBody(operation, "" + ); + + operation = addOperation( + output, + "new" + typeName, + "<BeanType extends " + typeName + "> BeanType", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "BeanType", "source"); + setOperationBody(operation, "" /*{ Class<BeanType> sourceType = typeOf<%=typeName%>(); Binder<BeanType, BeanType> binder = BinderFactory.newBinder(sourceType); BeanType result = new<%=typeName%>(source, binder); return result; }*/ - ); - - operation = addOperation( - output, - "new" + typeName, - "<BeanType extends " + typeName + "> BeanType", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - addParameter(operation, "BeanType", "source"); - addParameter(operation, "Binder<BeanType, BeanType>", "binder"); - setOperationBody(operation, "" + ); + + operation = addOperation( + output, + "new" + typeName, + "<BeanType extends " + typeName + "> BeanType", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "BeanType", "source"); + addParameter(operation, "Binder<BeanType, BeanType>", "binder"); + setOperationBody(operation, "" /*{ BeanType result = (BeanType) new<%=typeName%>(); binder.copy(source, result); return result; }*/ - ); - - } + ); + } - operation = addOperation( - output, - "copy" + typeName, - "<BeanType extends " + typeName + "> void", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - addParameter(operation, "BeanType", "source"); - addParameter(operation, "BeanType", "target"); - setOperationBody(operation, "" + protected void generateAbstractBeanDefaultsCopyMethods(ObjectModelClass output, String typeName) { + + ObjectModelOperation operation = addOperation( + output, + "copy" + typeName, + "<BeanType extends " + typeName + "> void", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "BeanType", "source"); + addParameter(operation, "BeanType", "target"); + setOperationBody(operation, "" /*{ Class<BeanType> sourceType = typeOf<%=typeName%>(); Binder<BeanType, BeanType> binder = BinderFactory.newBinder(sourceType); binder.copy(source, target); }*/ - ); - - operation = addOperation( - output, - "copy" + typeName, - "<BeanType extends " + typeName + "> void", - ObjectModelJavaModifier.STATIC, - ObjectModelJavaModifier.PUBLIC - ); - addParameter(operation, "BeanType", "source"); - addParameter(operation, "BeanType", "target"); - addParameter(operation, "Binder<BeanType, BeanType>", "binder"); - setOperationBody(operation, "" + ); + + operation = addOperation( + output, + "copy" + typeName, + "<BeanType extends " + typeName + "> void", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + addParameter(operation, "BeanType", "source"); + addParameter(operation, "BeanType", "target"); + addParameter(operation, "Binder<BeanType, BeanType>", "binder"); + setOperationBody(operation, "" /*{ binder.copy(source, target); }*/ - ); + ); - if (generatePredicates) { - generatePredicates(aClass, output, typeName); - } - - if (generateFunctions) { - generateFunctions(aClass, output, typeName); - } - } } - @Override - protected String getAttributeType(ObjectModelAttribute attr) { - String attrType = super.getAttributeType(attr); - if (!JavaGeneratorUtil.isPrimitiveType(attrType)) { - - boolean hasClass = model.hasClass(attrType); - if (hasClass) { - ObjectModelClass attributeClass = model.getClass(attrType); - String packageName = attributeClass.getPackageName(); - ObjectModelPackage attributePackage = model.getPackage(packageName); - if (JavaTemplatesStereoTypes.hasBeanStereotype(attributeClass, attributePackage)) { - - String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(attributeClass, attributePackage, model); - String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(attributeClass, attributePackage, model); - - String simpleType = JavaGeneratorUtil.getSimpleName(attrType); - attrType = generateName(classNamePrefix, simpleType, classNameSuffix); + protected void generateAbstractBeanDefaultsPredicates(ObjectModelClass input, ObjectModelClass output, String typeName) { - } - } - - } - return attrType; - } - - protected void generatePredicates(ObjectModelClass input, ObjectModelClass output, String typeName) { - - boolean atLeastOnePropertyfound=false; + boolean atLeastOnePropertyFound = false; for (ObjectModelAttribute attribute : getProperties(input)) { boolean multiple = JavaGeneratorUtil.isNMultiplicity(attribute); @@ -459,7 +429,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr continue; } - atLeastOnePropertyfound = true; + atLeastOnePropertyFound = true; String attrName = getAttributeName(attribute); String attrType = getAttributeType(attribute); addImport(output, attrType); @@ -467,7 +437,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr String simpleType = JavaGeneratorUtil.getSimpleName(attrType); String capitalizeAttrName = JavaGeneratorUtil.capitalizeJavaBeanPropertyName(attrName); - String newPreficateMethodName= "new" + capitalizeAttrName + "Predicate"; + String newPreficateMethodName = "new" + capitalizeAttrName + "Predicate"; ObjectModelOperation operation = addOperation( output, newPreficateMethodName, @@ -477,7 +447,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr ); addParameter(operation, simpleType, attrName); - String getterName = getGetterName(attrName, attribute); + String getterName = getGetterName(attribute, attrName); setOperationBody(operation, "" /*{ final <%=simpleType%> $tmp = <%=attrName%>; @@ -508,7 +478,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr ); } - if (atLeastOnePropertyfound) { + if (atLeastOnePropertyFound) { addImport(output, Predicate.class); addImport(output, Objects.class); addImport(output, Iterable.class); @@ -517,9 +487,9 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr } - protected void generateFunctions(ObjectModelClass input, ObjectModelClass output, String typeName) { + protected void generateAbstractBeanDefaultsFunctions(ObjectModelClass input, ObjectModelClass output, String typeName) { - boolean atLeastOnePropertyfound = false; + boolean atLeastOnePropertyFound = false; for (ObjectModelAttribute attribute : getProperties(input)) { boolean multiple = JavaGeneratorUtil.isNMultiplicity(attribute); @@ -528,7 +498,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr continue; } - atLeastOnePropertyfound = true; + atLeastOnePropertyFound = true; String attrName = getAttributeName(attribute); String attrType = getAttributeType(attribute); @@ -537,8 +507,8 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr String simpleType = JavaGeneratorUtil.getSimpleName(attrType); simpleType = wrapPrimitiveType(simpleType); String capitalizeAttrName = JavaGeneratorUtil.capitalizeJavaBeanPropertyName(attrName); - String newFunctionMethodName= "new" + capitalizeAttrName + "Function"; - String newFunctionTypeName= "Function<BeanType, " + simpleType + ">"; + String newFunctionMethodName = "new" + capitalizeAttrName + "Function"; + String newFunctionTypeName = "Function<BeanType, " + simpleType + ">"; ObjectModelOperation operation = addOperation( output, @@ -548,7 +518,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr ObjectModelJavaModifier.PUBLIC ); - String getterName = getGetterName(attrName, attribute); + String getterName = getGetterName(attribute, attrName); setOperationBody(operation, "" /*{ return new <%=newFunctionTypeName%>() { @@ -588,7 +558,7 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr ); } - if (atLeastOnePropertyfound) { + if (atLeastOnePropertyFound) { addImport(output, Function.class); addImport(output, Objects.class); addImport(output, ImmutableMap.class); @@ -598,59 +568,47 @@ public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTr } - protected String wrapPrimitiveType(String attrType) { - if (JavaGeneratorUtil.isPrimitiveType(attrType)) { - attrType = JavaGeneratorUtil.getPRimitiveWrapType(attrType); - } - return attrType; - } + protected String getAbstractDefaultsSuperClassName(ObjectModelPackage aPackage, ObjectModelClass aClass) { + String superClassName = null; - 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; + // test if a super class has bean stereotype + boolean superClassIsBean = false; + Collection<ObjectModelClass> superclasses = aClass.getSuperclasses(); + if (CollectionUtils.isNotEmpty(superclasses)) { + for (ObjectModelClass superclass : superclasses) { + superClassIsBean = beanDefaultClasses.contains(superclass); + if (superClassIsBean) { + superClassName = beanDefaultsNameTranslation.get(superclass); + break; + } + superClassName = superclass.getQualifiedName(); + } } - String getterName = getJavaBeanMethodName(methodPrefix, attrName); - return getterName; - } -// protected Collection<ObjectModelOperation> getPublicOperations(ObjectModelClass clazz) { -// -// Collection<ObjectModelOperation> result = new ArrayList<ObjectModelOperation>(); -// for (ObjectModelOperation operation : clazz.getOperations()) { -// -// ObjectModelJavaModifier visibility = ObjectModelJavaModifier.fromVisibility(operation.getVisibility()); -// if (ObjectModelJavaModifier.PUBLIC == visibility) { -// result.add(operation); -// } -// } -// return result; -// } - - protected String getBeanClassName(ObjectModelPackage aPackage, ObjectModelClass input) { - String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(input, aPackage, model); - String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(input, aPackage, model); - - return generateName(classNamePrefix, input.getName(), classNameSuffix); - } + if (!superClassIsBean) { - protected String getBeanDefaultsClassName(ObjectModelPackage aPackage, ObjectModelClass input) { - String classNamePrefix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(input, aPackage, model); - String classNameSuffix = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(input, aPackage, model); - return generateName(classNamePrefix, input.getName(), classNameSuffix); - } + // try to find a super class by tag-value + superClassName = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(aClass, aPackage, model); - protected String generateName(String prefix, String name, String suffix) { - StringBuilder sb = new StringBuilder(); - if (StringUtils.isNotEmpty(prefix)) { - sb.append(prefix); } - sb.append(name); - if (StringUtils.isNotEmpty(suffix)) { - sb.append(suffix); + return superClassName; + } + + @Override + protected String getAttributeType(ObjectModelAttribute attr) { + String attrType = super.getAttributeType(attr); + if (!JavaGeneratorUtil.isPrimitiveType(attrType)) { + boolean hasClass = model.hasClass(attrType); + if (hasClass) { + ObjectModelClass attributeClass = model.getClass(attrType); + String attributeType = beanNameTranslation.get(attributeClass); + if (attributeType != null) { + attrType = attributeType; + } + } } - return sb.toString(); + return attrType; } + } diff --git a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java index 3e5ada9..28293a3 100644 --- a/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java +++ b/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java @@ -163,7 +163,7 @@ public class GeneratorUtil { * @return the wrap primitive type * @since 3.0 */ - public static String getPRimitiveWrapType(String type) { + public static String getPrimitiveWrapType(String type) { if ("byte".equals(type)) { return "Byte"; } -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
participants (1)
-
nuiton.org scm