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>.