branch develop updated (d1820b8 -> 254adfb)
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 d1820b8 fixes #3701: Use nuitonpom 2.1 adds 133aab9 use helper-maven-plugin 2.2-SNAPSHOT adds dfb19b9 requires jdk 7 adds f729988 use helper-maven-plugin 2.2 (refs #3704) adds 5fe9461 fixes #3704: Use helper-maven-plugin 2.2 Merge branch 'feature/3704' into develop new 6cfc552 Add the new generator SimpleJavaBeanWithNoInterfaceTransformer new 254adfb Introduce SimpleBeanWithNoInterfaceTransformer (fixes #3736) Merge branch 'feature/3736' into develop The 2 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 254adfb903afeb9c7ae49187b49363d59e5d64ad Merge: 5fe9461 6cfc552 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 27 21:39:08 2015 +0200 Introduce SimpleBeanWithNoInterfaceTransformer (fixes #3736) Merge branch 'feature/3736' into develop commit 6cfc55216442981ee5908d39656e335a1e38eeca Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 27 21:38:54 2015 +0200 Add the new generator SimpleJavaBeanWithNoInterfaceTransformer Summary of changes: .../nuiton/eugene/java/JavaTemplatesTagValues.java | 271 +++++++++++++++ .../SimpleJavaBeanWithNoInterfaceTransformer.java | 368 +++++++++++++++++++++ eugene-maven-plugin/pom.xml | 7 +- pom.xml | 28 +- 4 files changed, 655 insertions(+), 19 deletions(-) create mode 100644 eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java -- 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 6cfc55216442981ee5908d39656e335a1e38eeca Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 27 21:38:54 2015 +0200 Add the new generator SimpleJavaBeanWithNoInterfaceTransformer --- .../nuiton/eugene/java/JavaTemplatesTagValues.java | 271 +++++++++++++++ .../SimpleJavaBeanWithNoInterfaceTransformer.java | 368 +++++++++++++++++++++ 2 files changed, 639 insertions(+) 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 37a638e..c470751 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 @@ -362,6 +362,160 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { public static final String TAG_SIMPLE_BEAN_DEFAULTS_CLASS_NAME_SUFFIX = "simpleBeanDefaultsClassNameSuffix"; /** + * Tag value to use a super class for generated bean. + * + * If the bean needs Property change support (says you use the tag-value {@link #TAG_GENERATE_PROPERTY_CHANGE_SUPPORT}, + * then your class must provide evrything for it. + * + * More over, if you use some collections in your bean you must also define + * two method named {@code getChild(Collection list, int index)} and + * {@code getChild(List list, int index)} + * + * See new code to know minimum stuff to add in your class for this purpose. + * <pre> + * public abstract class AbstractBean implements Serializable { + * + * private static final long serialVersionUID = 1L; + * + * protected final PropertyChangeSupport pcs = new PropertyChangeSupport(this); + * + * public void addPropertyChangeListener(PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(listener); + * } + * + * public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.addPropertyChangeListener(propertyName, listener); + * } + * + * public void removePropertyChangeListener(PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(listener); + * } + * + * public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) { + * pcs.removePropertyChangeListener(propertyName, listener); + * } + * + * protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) { + * pcs.firePropertyChange(propertyName, oldValue, newValue); + * } + * + * protected void firePropertyChange(String propertyName, Object newValue) { + * firePropertyChange(propertyName, null, newValue); + * } + * + * protected <T> T getChild(Collection<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * + * protected <T> T getChild(List<T> list, int index) { + * return CollectionUtil.getOrNull(list, index); + * } + * } + * </pre> + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + documentation = "To specify a super-class to used on generated simple bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_SUPER_CLASS = "simpleBeanWithNoInterfaceSuperClass"; + + /** + * To generate a factory of generated simple beans. + * + * You must use it on the complete model. + * + * @see #isSimpleBeanWithNoInterfaceGenerateDefaults(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + defaultValue = "true", + documentation = "To generate defaults class with simple operations on the type.\n" + + "(only effective with simple bean generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_DEFAULTS = "simpleBeanWithNoInterfaceGenerateDefaults"; + + /** + * Tag value to use a super super-class for generated defaults class of a simple bean. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + documentation = "To specify a super-class to used on generated defaults classes" + + "for a bean or any bean of a model.\n" + + "(only effective with simple bean generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_SUPER_CLASS = "simpleBeanWithNoInterfaceDefaultsSuperClass"; + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanClassNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + documentation = "To add a prefix on class name of generated bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean with no interface generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_CLASS_NAME_PREFIX = "simpleBeanWithNoInterfaceClassNamePrefix"; + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanClassNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + documentation = "To add a suffix on class name of generated bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean with no interface generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_CLASS_NAME_SUFFIX = "simpleBeanWithNoInterfaceClassNameSuffix"; + + /** + * To add a prefix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + documentation = "To add a prefix on class name of generated defaults bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_PREFIX = "simpleBeanWithNoInterfaceDefaultsClassNamePrefix"; + + /** + * To add a suffix on the name of each generated bean class. + * + * You can globaly use it on the complete model or to a specific classifier. + * + * @see #getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(ObjectModelClassifier, ObjectModelPackage, ObjectModel) + * @since 3.0 + */ + @TagValueDefinition( + target = {ObjectModel.class, ObjectModelPackage.class, ObjectModelClassifier.class}, + documentation = "To add a suffix on class name of generated defaults bean " + + "for a class or any class of a model.\n" + + "(only effective with simple bean generator)") + public static final String TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_SUFFIX = "simpleBeanWithNoInterfaceDefaultsClassNameSuffix"; + + /** * Obtain the value of the {@link #TAG_GENERATE_PROPERTY_CHANGE_SUPPORT} tag value on the given model, package or classifier. * <p/> * It will first look on the model, then and package and then in the given classifier. @@ -609,4 +763,121 @@ public class JavaTemplatesTagValues extends TagValueDefinitionProvider { return value; } + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_SUPER_CLASS} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @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_SUPER_CLASS + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = findTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_SUPER_CLASS, classifier, aPackage, model); + return value; + } + + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_DEFAULTS} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @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_DEFAULTS + * @since 3.0 + */ + public boolean isSimpleBeanWithNoInterfaceGenerateDefaults(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + boolean value = findBooleanTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_GENERATE_DEFAULTS, classifier, aPackage, model); + return value; + } + + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_SUPER_CLASS} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @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_DEFAULTS_SUPER_CLASS + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = findTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_SUPER_CLASS, classifier, aPackage, model); + return value; + } + + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_CLASS_NAME_PREFIX} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @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_CLASS_NAME_PREFIX + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceClassNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = findTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_CLASS_NAME_PREFIX, classifier, aPackage, model); + return value; + } + + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_CLASS_NAME_SUFFIX} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @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_CLASS_NAME_SUFFIX + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceClassNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = findTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_CLASS_NAME_SUFFIX, classifier, aPackage, model); + return value; + } + + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_PREFIX} tag value on the given model or classifier. + * + * It will first look on the model, and then in the given classifier. + * + * @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_DEFAULTS_CLASS_NAME_PREFIX + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceDefaultsClassNamePrefixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = findTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_PREFIX, classifier, aPackage, model); + return value; + } + + /** + * Obtain the value of the {@link #TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_SUFFIX} 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_DEFAULTS_CLASS_NAME_SUFFIX + * @since 3.0 + */ + public String getSimpleBeanWithNoInterfaceDefaultsClassNameSuffixTagValue(ObjectModelClassifier classifier, ObjectModelPackage aPackage, ObjectModel model) { + String value = findTagValue(TAG_SIMPLE_BEAN_WITH_NO_INTERFACE_DEFAULTS_CLASS_NAME_SUFFIX, classifier, aPackage, model); + if (StringUtils.isBlank(value)) { + value = "s"; + } + 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 new file mode 100644 index 0000000..c38e55b --- /dev/null +++ b/eugene-java-templates/src/main/java/org/nuiton/eugene/java/SimpleJavaBeanWithNoInterfaceTransformer.java @@ -0,0 +1,368 @@ +package org.nuiton.eugene.java; + +/*{generator option: parentheses = false}*/ +/*{generator option: writeString = +}*/ + +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.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelJavaModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; +import org.nuiton.eugene.models.object.ObjectModelPackage; +import org.nuiton.util.beans.Binder; +import org.nuiton.util.beans.BinderFactory; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** + * Generates a java bean and a utility class around it. This transformer acts like {@link SimpleJavaBeanTransformer} + * but with no interface generation (plus there is not factory generation at all). + * + * For example: + * <pre> + * AbstractBoat + * Boat (extends AbstractBoat) + * AbstractBoats + * Boats (extends AbstractBoats) + * </pre> + * + * @author Tony Chemit - chemit@codelutin.com + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.eugene.java.SimpleJavaBeanWithNoInterfaceTransformer" + * @since 3.0 + */ +public class SimpleJavaBeanWithNoInterfaceTransformer extends AbstractJavaBeanTransformer { + + /** Logger. */ + private static final Log log = LogFactory.getLog(SimpleJavaBeanWithNoInterfaceTransformer.class); + + @Override + public void transformFromClass(ObjectModelClass input) { + + ObjectModelPackage aPackage = getPackage(input); + + if (JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage)) { + + String className = getBeanClassName(aPackage, input); + String abstractClassName = "Abstract" + className; + String defaultClassName = getBeanDefaultsClassName(aPackage, input); + String abstractDefaultClassName = "Abstract" + defaultClassName; + + boolean generateDefaults = canGenerateBeanDefaults(aPackage, input); + boolean generateAbstractClass = canGenerateAbstractBean(input, abstractClassName); + boolean generateClass = canGenerateBean(input, className); + + String prefix = getConstantPrefix(input); + setConstantPrefix(prefix); + + if (generateAbstractClass) { + generateAbstractBeanClass(aPackage, input, abstractClassName); + } + + if (generateClass) { + generateBeanClass(input, className, abstractClassName); + } + + if (generateDefaults) { + generateBeanDefaults(aPackage, input, className, abstractDefaultClassName, defaultClassName); + } + } + + } + + 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); + + if (canGenerate) { + + // 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."); + } + } + return canGenerate; + } + + protected boolean canGenerateBeanDefaults(ObjectModelPackage aPackage, ObjectModelClass input) { + + boolean withInput = input != null; + + boolean canGenerate = getJavaTemplatesTagValues().isSimpleBeanWithNoInterfaceGenerateDefaults(input, aPackage, model); + + if (canGenerate) { + + if (withInput) { + + // class in not abstract + // class is a bean + + canGenerate = !input.isAbstract() && JavaTemplatesStereoTypes.hasBeanStereotype(input, aPackage); + + } + } + + return canGenerate; + } + + protected ObjectModelClass generateBeanClass(ObjectModelClass input, + String className, + String abstractClassName) { + + ObjectModelClass output; + + if (input.isAbstract()) { + output = createAbstractClass(className, input.getPackageName()); + } else { + output = createClass(className, input.getPackageName()); + } + + setSuperClass(output, abstractClassName); + + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); + } + + addSerializable(input, output, true); + + return output; + } + + protected ObjectModelClass generateAbstractBeanClass(ObjectModelPackage aPackage, + ObjectModelClass input, + String className) { + + String superClass = null; + + // test if a super class has bean stereotype + boolean superClassIsBean = false; + 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); + break; + } else { + superClass = superclass.getQualifiedName(); + } + } + } + + if (!superClassIsBean) { + + // try to find a super class by tag-value + superClass = getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceSuperClassTagValue(input, aPackage, model); + if (superClass != null) { + + // will act as if super class is a bean + superClassIsBean = true; + } + } + + ObjectModelClass output; + + output = createAbstractClass(className, input.getPackageName()); + + if (superClass != null) { + setSuperClass(output, superClass); + } + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); + } + + boolean serializableFound; + + serializableFound = addInterfaces(input, output, null); + + generateI18nBlockAndConstants(aPackage, input, output); + + addSerializable(input, output, serializableFound || superClassIsBean); + + // Get available properties + 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); + + // Add properties field + javabean methods + for (ObjectModelAttribute attr : properties) { + + createProperty(output, + attr, + usePCS, + generateBooleanGetMethods, + generateNotEmptyCollections); + } + + if (!superClassIsBean) { + addDefaultMethodForNoneBeanSuperClass(output, usePCS, properties); + } + return output; + } + + protected void generateBeanDefaults(ObjectModelPackage aPackage, + ObjectModelClass aClass, + String typeName, + String abstractClassName, + String defaultClassName) { + + boolean generateDefault = canGenerateBeanDefaults(aPackage, aClass); + + if (!generateDefault) { + return; + } + + String packageName = aClass.getPackageName(); +// String typeName = getBeanInterfaceName(aPackage, aClass); +// String typeBeanName = getBeanClassName(aPackage, aClass); + + if (!isInClassPath(packageName, defaultClassName)) { + + // generate defaults class + + ObjectModelClass output = createClass(defaultClassName, packageName); + setSuperClass(output, packageName + "." + abstractClassName); + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); + } + } + + if (!isInClassPath(packageName, abstractClassName)) { + + // generate abstract defaults class + + // try to find a super class by tag-value + String superClassName = + getJavaTemplatesTagValues().getSimpleBeanWithNoInterfaceDefaultsSuperClassTagValue( + aClass, aPackage, model); + + ObjectModelClass output = createAbstractClass(abstractClassName, packageName); + if (StringUtils.isNotBlank(superClassName)) { + setSuperClass(output, superClassName); + } + + if (log.isDebugEnabled()) { + log.debug("will generate " + output.getQualifiedName()); + } + + ObjectModelOperation operation = addOperation( + output, + "typeOf" + typeName, + "<BeanType extends " + typeName + "> Class<BeanType>", + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + setOperationBody(operation, "" + /*{ + return (Class<BeanType>) <%=typeName%>.class; + }*/ + ); + operation = addOperation( + output, + "new" + typeName, + typeName, + ObjectModelJavaModifier.STATIC, + ObjectModelJavaModifier.PUBLIC + ); + setOperationBody(operation, "" + /*{ + return new <%=typeName%>(); + }*/ + ); + + addImport(output, Binder.class); + addImport(output, BinderFactory.class); + 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, "" + /*{ + BeanType result = (BeanType) new<%=typeName%>(); + binder.copy(source, result); + return result; + }*/ + ); + } + } + + 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); + } + + 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); + } + + 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(); + } +} + -- 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 254adfb903afeb9c7ae49187b49363d59e5d64ad Merge: 5fe9461 6cfc552 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 27 21:39:08 2015 +0200 Introduce SimpleBeanWithNoInterfaceTransformer (fixes #3736) Merge branch 'feature/3736' into develop .../nuiton/eugene/java/JavaTemplatesTagValues.java | 271 +++++++++++++++ .../SimpleJavaBeanWithNoInterfaceTransformer.java | 368 +++++++++++++++++++++ 2 files changed, 639 insertions(+) -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
participants (1)
-
nuiton.org scm