Author: tchemit Date: 2010-05-13 19:15:46 +0200 (Thu, 13 May 2010) New Revision: 903 Url: http://nuiton.org/repositories/revision/eugene/903 Log: add constant prefix api Modified: trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaInterfaceTransformer.java trunk/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java Modified: trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java 2010-05-11 12:19:39 UTC (rev 902) +++ trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaBeanTransformer.java 2010-05-13 17:15:46 UTC (rev 903) @@ -27,7 +27,11 @@ import org.apache.commons.lang.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.eugene.models.object.*; +import org.nuiton.eugene.models.object.ObjectModelAttribute; +import org.nuiton.eugene.models.object.ObjectModelClass; +import org.nuiton.eugene.models.object.ObjectModelInterface; +import org.nuiton.eugene.models.object.ObjectModelModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; import java.beans.PropertyChangeListener; import java.beans.PropertyChangeSupport; @@ -35,6 +39,7 @@ import java.util.Collection; import java.util.Iterator; import java.util.List; +import java.util.Set; /*{generator option: parentheses = false}*/ /*{generator option: writeString = +}*/ @@ -44,94 +49,104 @@ * (and nothing else) according to the JavaBeans 1.1 norm. * * @author tchemit <chemit@codelutin.com> + * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.eugene.java.JavaBeanTransformer" * @since 2.0.2 - * @plexus.component role="org.nuiton.eugene.Template" role-hint="org.nuiton.eugene.java.JavaBeanTransformer" */ public class JavaBeanTransformer extends ObjectModelTransformerToJava { private static final Log log = LogFactory.getLog(JavaBeanTransformer.class); + public static final String DEFAULT_CONSTANT_PREFIX = "PROPERTY_"; + @Override - public void transformFromClass(ObjectModelClass clazz) { - if (!canGenerate(clazz)) { + public void transformFromClass(ObjectModelClass input) { + if (!canGenerate(input)) { if (log.isDebugEnabled()) { - log.debug("Skip generation for "+clazz.getQualifiedName()); + log.debug("Skip generation for " + input.getQualifiedName()); } return; } - ObjectModelClass resultClass = - createAbstractClass(clazz.getName(), clazz.getPackageName()); + ObjectModelClass output = + createAbstractClass(input.getName(), input.getPackageName()); if (log.isDebugEnabled()) { - log.debug("will generate "+ resultClass.getQualifiedName()); + log.debug("will generate " + output.getQualifiedName()); } - ObjectModelClass resultClassImpl = generateImpl(clazz, resultClass); + ObjectModelClass ouputImpl = generateImpl(input, output); if (log.isDebugEnabled()) { - if (resultClassImpl == null) { + if (ouputImpl == null) { log.debug("will generate impl " + - resultClass.getQualifiedName()); + output.getQualifiedName()); } else { log.debug("do not generate existing impl " + - resultClass.getQualifiedName()); + output.getQualifiedName()); } } + + String prefix = getConstantPrefix(input, DEFAULT_CONSTANT_PREFIX); - addSuperClass(clazz, resultClass, resultClassImpl); + setConstantPrefix(prefix); - addInterfaces(clazz, resultClass); + addSuperClass(input, output, ouputImpl); + addInterfaces(input, output); + + Set<String> constantNames = addConstantsFromDependency(input, output); + // Get available properties - List<ObjectModelAttribute> properties = getProperties(clazz); + List<ObjectModelAttribute> properties = getProperties(input); // Add properties constant for (ObjectModelAttribute attr : properties) { - createPropertyConstant(resultClass, attr); + createPropertyConstant(output, attr, prefix, constantNames); } // Add properties field + javabean methods for (ObjectModelAttribute attr : properties) { - createProperty(resultClass, attr); + createProperty(output, attr); } - + // Add operations - createAbstractOperations(resultClass, clazz.getOperations()); + createAbstractOperations(output, input.getOperations()); // Add property change support - createPropertyChangeSupport(resultClass); + createPropertyChangeSupport(output); boolean hasAMultipleProperty = containsMutiple(properties); // Add helper operations if (hasAMultipleProperty) { - createGetChildMethod(resultClass); + createGetChildMethod(output); } } - @Override - public String getConstantName(String propertyName) { - return "PROPERTY_" + super.getConstantName(propertyName); - } + protected void createPropertyConstant(ObjectModelClass output, + ObjectModelAttribute attr, + String prefix, + Set<String> constantNames) { - protected void createPropertyConstant(ObjectModelClass resultClass, - ObjectModelAttribute attr) { - String attrName = getAttributeName(attr); - String constantName = getConstantName(attrName); + String constantName = prefix + builder.getConstantName(attrName); - addConstant(resultClass, + if (constantNames.contains(constantName)) { + + // already generated + return; + } + + addConstant(output, constantName, String.class, "\"" + attrName + "\"", ObjectModelModifier.PUBLIC ); - } protected String getAttributeName(ObjectModelAttribute attr) { @@ -167,9 +182,8 @@ return result; } - protected void createProperty( - ObjectModelClass resultClass, - ObjectModelAttribute attr) { + protected void createProperty(ObjectModelClass output, + ObjectModelAttribute attr) { String attrName = getAttributeName(attr); String attrType = getAttributeType(attr); @@ -183,21 +197,21 @@ if (multiple) { - createGetChildMethod(resultClass, + createGetChildMethod(output, attrName, attrNameCapitalized, attrType, simpleType ); - createAddChildMethod(resultClass, + createAddChildMethod(output, attrName, attrNameCapitalized, attrType, constantName ); - createRemoveChildMethod(resultClass, + createRemoveChildMethod(output, attrName, attrNameCapitalized, attrType, @@ -214,13 +228,13 @@ simpleType = JavaGeneratorUtil.getSimpleName(attrType); } - createGetMethod(resultClass, + createGetMethod(output, attrName, attrNameCapitalized, attrType ); - createSetMethod(resultClass, + createSetMethod(output, attrName, attrNameCapitalized, attrType, @@ -229,7 +243,7 @@ ); // Add attribute to the class - addAttribute(resultClass, + addAttribute(output, attrName, attrType, "", @@ -238,19 +252,20 @@ } - protected void createAbstractOperations(ObjectModelClass resultClass, + protected void createAbstractOperations(ObjectModelClass ouput, Iterable<ObjectModelOperation> operations) { JavaGeneratorUtil.cloneOperations( this, operations, - resultClass, + ouput, true, ObjectModelModifier.ABSTRACT ); } - protected List<ObjectModelAttribute> getProperties(ObjectModelClass clazz) { + + protected List<ObjectModelAttribute> getProperties(ObjectModelClass input) { List<ObjectModelAttribute> attributes = - (List<ObjectModelAttribute>) clazz.getAttributes(); + (List<ObjectModelAttribute>) input.getAttributes(); List<ObjectModelAttribute> attrs = new ArrayList<ObjectModelAttribute>(); @@ -264,12 +279,12 @@ return attrs; } - protected void createGetMethod(ObjectModelClass resultClass, + protected void createGetMethod(ObjectModelClass output, String attrName, String attrNameCapitalized, String attrType) { ObjectModelOperation getter = addOperation( - resultClass, + output, "get" + attrNameCapitalized, attrType, ObjectModelModifier.PUBLIC @@ -280,13 +295,14 @@ }*/ ); } - protected void createGetChildMethod(ObjectModelClass resultClass, + + protected void createGetChildMethod(ObjectModelClass output, String attrName, String attrNameCapitalized, String attrType, String simpleType) { ObjectModelOperation getChild = addOperation( - resultClass, + output, "get" + attrNameCapitalized, attrType, ObjectModelModifier.PUBLIC @@ -300,13 +316,13 @@ ); } - protected void createAddChildMethod(ObjectModelClass resultClass, + protected void createAddChildMethod(ObjectModelClass output, String attrName, String attrNameCapitalized, String attrType, String constantName) { ObjectModelOperation addChild = addOperation( - resultClass, + output, "add" + attrNameCapitalized, "void", ObjectModelModifier.PUBLIC @@ -320,13 +336,13 @@ ); } - protected void createRemoveChildMethod(ObjectModelClass resultClass, + protected void createRemoveChildMethod(ObjectModelClass output, String attrName, String attrNameCapitalized, String attrType, String constantName) { ObjectModelOperation operation = addOperation( - resultClass, + output, "remove" + attrNameCapitalized, "boolean", ObjectModelModifier.PUBLIC @@ -343,14 +359,14 @@ ); } - protected void createSetMethod(ObjectModelClass resultClass, + protected void createSetMethod(ObjectModelClass output, String attrName, String attrNameCapitalized, String attrType, String simpleType, String constantName) { ObjectModelOperation operation = addOperation( - resultClass, + output, "set" + attrNameCapitalized, "void", ObjectModelModifier.PUBLIC @@ -366,9 +382,9 @@ ); } - protected void createGetChildMethod(ObjectModelClass resultClass) { + protected void createGetChildMethod(ObjectModelClass output) { ObjectModelOperation getChild = addOperation( - resultClass, + output, "getChild", "<T> T", ObjectModelModifier.PROTECTED ); @@ -390,59 +406,59 @@ ); } - protected void addInterfaces(ObjectModelClass clazz, - ObjectModelClass resultClass) { + protected void addInterfaces(ObjectModelClass input, + ObjectModelClass output) { // Add interfaces from inputModel - for (ObjectModelInterface parentInterface : clazz.getInterfaces()) { - addInterface(resultClass, parentInterface.getQualifiedName()); + for (ObjectModelInterface parentInterface : input.getInterfaces()) { + addInterface(output, parentInterface.getQualifiedName()); } } - protected void addSuperClass(ObjectModelClass clazz, - ObjectModelClass resultClass, - ObjectModelClass resultClassImpl) { + protected void addSuperClass(ObjectModelClass input, + ObjectModelClass output, + ObjectModelClass outputImpl) { // Set superclass - if (resultClassImpl == null) { - Iterator<ObjectModelClass> j = clazz.getSuperclasses().iterator(); + if (outputImpl == null) { + Iterator<ObjectModelClass> j = input.getSuperclasses().iterator(); if (j.hasNext()) { ObjectModelClass p = j.next(); // We want to set the inheritance to the implementation class of the father // Ex for model : A -> B (a inherits B) we want : A -> BImpl -> B String qualifiedName = p.getQualifiedName() + "Impl"; - setSuperClass(resultClass, qualifiedName); + setSuperClass(output, qualifiedName); } } } - protected ObjectModelClass generateImpl(ObjectModelClass clazz, - ObjectModelClass resultClass) { + protected ObjectModelClass generateImpl(ObjectModelClass input, + ObjectModelClass output) { // Get name for Impl class - String implQualifiedName = clazz.getQualifiedName() + "Impl"; + String implQualifiedName = input.getQualifiedName() + "Impl"; // Does bean own operations ? - boolean hasOperations = !clazz.getAllOtherOperations(true).isEmpty() || - !clazz.getOperations().isEmpty(); + boolean hasOperations = !input.getAllOtherOperations(true).isEmpty() || + !input.getOperations().isEmpty(); String resourceName = "/" + implQualifiedName.replaceAll("\\.", "/"); - ObjectModelClass resultClassImpl=null; + ObjectModelClass resultClassImpl = null; // Generate the Impl class if not already exist in classpath and no operation is defined in model - if(getClass().getResource(resourceName) == null && !hasOperations) { - String implName = clazz.getName() + "Impl"; - resultClassImpl = createClass(implName, clazz.getPackageName()); + if (getClass().getResource(resourceName) == null && !hasOperations) { + String implName = input.getName() + "Impl"; + resultClassImpl = createClass(implName, input.getPackageName()); // set the abstract resulClass as the resultClassImpl super class - setSuperClass(resultClassImpl, resultClass.getQualifiedName()); + setSuperClass(resultClassImpl, output.getQualifiedName()); } return resultClassImpl; } - protected boolean canGenerate(ObjectModelClass clazz) { - return clazz.hasStereotype(JavaGeneratorUtil.STEREOTYPE_BEAN); + protected boolean canGenerate(ObjectModelClass input) { + return input.hasStereotype(JavaGeneratorUtil.STEREOTYPE_BEAN); } - protected void createPropertyChangeSupport(ObjectModelClass resultClass) { + protected void createPropertyChangeSupport(ObjectModelClass output) { - addAttribute(resultClass, + addAttribute(output, "pcs", PropertyChangeSupport.class, "new PropertyChangeSupport(this);", @@ -453,8 +469,8 @@ // Add PropertyListener ObjectModelOperation operation; - - operation = addOperation(resultClass, + + operation = addOperation(output, "addPropertyChangeListener", "void", ObjectModelModifier.PUBLIC @@ -466,7 +482,7 @@ }*/ ); - operation = addOperation(resultClass, + operation = addOperation(output, "addPropertyChangeListener", "void", ObjectModelModifier.PUBLIC @@ -479,7 +495,7 @@ }*/ ); - operation = addOperation(resultClass, + operation = addOperation(output, "removePropertyChangeListener", "void", ObjectModelModifier.PUBLIC @@ -491,10 +507,10 @@ }*/ ); - operation= addOperation(resultClass, - "removePropertyChangeListener", - "void", - ObjectModelModifier.PUBLIC + operation = addOperation(output, + "removePropertyChangeListener", + "void", + ObjectModelModifier.PUBLIC ); addParameter(operation, String.class, "propertyName"); addParameter(operation, PropertyChangeListener.class, "listener"); @@ -504,7 +520,7 @@ }*/ ); - operation = addOperation(resultClass, + operation = addOperation(output, "firePropertyChange", "void", ObjectModelModifier.PROTECTED @@ -518,7 +534,7 @@ }*/ ); - operation = addOperation(resultClass, + operation = addOperation(output, "firePropertyChange", "void", ObjectModelModifier.PROTECTED Modified: trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaInterfaceTransformer.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaInterfaceTransformer.java 2010-05-11 12:19:39 UTC (rev 902) +++ trunk/eugene/src/main/java/org/nuiton/eugene/java/JavaInterfaceTransformer.java 2010-05-13 17:15:46 UTC (rev 903) @@ -29,14 +29,11 @@ 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.ObjectModelClassifier; -import org.nuiton.eugene.models.object.ObjectModelDependency; -import org.nuiton.eugene.models.object.ObjectModelEnumeration; import org.nuiton.eugene.models.object.ObjectModelInterface; import org.nuiton.eugene.models.object.ObjectModelModifier; -import java.util.Collection; import java.util.Iterator; +import java.util.Set; /*{generator option: parentheses = false}*/ /*{generator option: writeString = +}*/ @@ -56,89 +53,77 @@ LogFactory.getLog(JavaInterfaceTransformer.class); @Override - public void transformFromInterface(ObjectModelInterface interfacez) { + public void transformFromInterface(ObjectModelInterface input) { // Can only generate an interface with no stereotypes - if (!interfacez.getStereotypes().isEmpty()) { + if (!input.getStereotypes().isEmpty()) { return; } - ObjectModelInterface resultInterface = createInterface( - interfacez.getName(), interfacez.getPackageName()); + ObjectModelInterface output = createInterface(input.getName(), + input.getPackageName()); if (log.isDebugEnabled()) { log.debug("generate interface " + - resultInterface.getQualifiedName()); + output.getQualifiedName()); } // extend interface Iterator<ObjectModelInterface> it = - interfacez.getInterfaces().iterator(); + input.getInterfaces().iterator(); if (it.hasNext()) { ObjectModelInterface extend = it.next(); - addInterface(resultInterface, extend.getQualifiedName()); + addInterface(output, extend.getQualifiedName()); } - // constant attributes - for (ObjectModelAttribute attr : interfacez.getAttributes()) { - // only static attribut with value - if (!attr.isStatic() && - StringUtils.isNotEmpty(attr.getDefaultValue())) { - addConstant(resultInterface, - attr.getName(), - attr.getType(), - attr.getDefaultValue(), - ObjectModelModifier.PUBLIC - ); + String prefix = getConstantPrefix(input, ""); + + if (StringUtils.isEmpty(prefix)) { + + // no specific prefix, so no prefix + if (log.isWarnEnabled()) { + log.warn("[" + input.getName() + "] Will generate constants with NO prefix, not a good idea..."); } } + setConstantPrefix(prefix); - // constant attributes via 'constants' enumeration dependency - // literals of enumeration will be values and constant name will be generated - ObjectModelDependency constantsDependencies = - interfacez.getDependency(JavaGeneratorUtil.DEPENDENCIES_CONSTANTS); - if (constantsDependencies != null) { + Set<String> constants = addConstantsFromDependency(input, output); - ObjectModelClassifier classifier = constantsDependencies.getSupplier(); + // constant attributes + for (ObjectModelAttribute attr : input.getAttributes()) { - if (classifier instanceof ObjectModelEnumeration) { + if (attr.isStatic() || + !StringUtils.isNotEmpty(attr.getDefaultValue())) { - ObjectModelEnumeration constants = - (ObjectModelEnumeration) classifier; + // only static attribut with value + continue; + } - // look if there is a constant_prefix tag value - String prefix = JavaGeneratorUtil.findTagValue( - JavaGeneratorUtil.TAG_CONSTANT_PREFIX, - constants, - null - ); + String constantName = attr.getName(); - if (prefix==null) { - prefix = ""; - } + if (constants.contains(constantName)) { - // add all literal of dependency as constants in interface - Collection<String> literals = constants.getLiterals(); - for (String literal : literals) { - - String constantName = prefix + getConstantName(literal); - - addConstant(resultInterface, - constantName, - String.class, - "\"" + literal + "\"", - ObjectModelModifier.PUBLIC - ); - } + // already generated + continue; } + + // add constant + addConstant(output, + constantName, + attr.getType(), + attr.getDefaultValue(), + ObjectModelModifier.PUBLIC + ); } + // interface operations JavaGeneratorUtil.cloneOperations(this, - interfacez.getOperations(), - resultInterface, + input.getOperations(), + output, false ); } + } Modified: trunk/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java 2010-05-11 12:19:39 UTC (rev 902) +++ trunk/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java 2010-05-13 17:15:46 UTC (rev 903) @@ -25,11 +25,29 @@ package org.nuiton.eugene.java; +import org.apache.commons.lang.StringUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.eugene.Template; -import org.nuiton.eugene.models.object.*; +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.ObjectModelClassifier; +import org.nuiton.eugene.models.object.ObjectModelDependency; +import org.nuiton.eugene.models.object.ObjectModelElement; +import org.nuiton.eugene.models.object.ObjectModelEnumeration; +import org.nuiton.eugene.models.object.ObjectModelInterface; +import org.nuiton.eugene.models.object.ObjectModelModifier; +import org.nuiton.eugene.models.object.ObjectModelOperation; +import org.nuiton.eugene.models.object.ObjectModelParameter; +import org.nuiton.eugene.models.object.ObjectModelTransformer; +import org.nuiton.eugene.models.object.ObjectModelType; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + /** * Created: 28 oct. 2009 * @@ -39,11 +57,12 @@ private static final Log log = LogFactory.getLog(ObjectModelTransformerToJava.class); - /** - * internal builder - */ + + /** internal builder */ protected JavaBuilder builder; + private String constantPrefix; + @Override protected Template<ObjectModel> initOutputTemplate() { // by default, use a stupid java generator @@ -56,6 +75,7 @@ log.debug("inputModelName = " + getModel().getName()); } builder = new JavaBuilder(getModel().getName()); + setConstantPrefix(""); return builder.getModel(); } @@ -139,9 +159,27 @@ } public String getConstantName(String propertyName) { - return builder.getConstantName(propertyName); + return getConstantPrefix() + builder.getConstantName(propertyName); } + protected String getConstantPrefix(ObjectModelClassifier input, + String defaultPrefix) { + + // look if there is a constant_prefix tag value + String prefix = JavaGeneratorUtil.findTagValue( + JavaGeneratorUtil.TAG_CONSTANT_PREFIX, + input, + getModel() + ); + + if (StringUtils.isEmpty(prefix)) { + + // no specific prefix, use default prefix + prefix = defaultPrefix; + } + return prefix.trim(); + } + protected ObjectModelAttribute addConstant( ObjectModelClassifier classifier, String name, @@ -277,4 +315,71 @@ ObjectModelModifier... modifiers) { return builder.addBlock(classifier, modifiers); } + + /** + * Search in {@code input} model, for a enumeration dependency named + * {@link JavaGeneratorUtil#DEPENDENCIES_CONSTANTS}. + * <p/> + * If found, add all literals on {@code output} model as constants. + * <p/> + * You can add a {@link JavaGeneratorUtil#TAG_CONSTANT_PREFIX} to your + * enumeration to prefix constant names. + * + * @param input the input model + * @param output the ouput model + * @return the set of constants names generated + */ + protected Set<String> addConstantsFromDependency(ObjectModelClassifier input, + ObjectModelClassifier output) { + + // constant attributes via 'constants' enumeration dependency + // literals of enumeration will be values and constant name will be generated + ObjectModelDependency constantsDependencies = + input.getDependency(JavaGeneratorUtil.DEPENDENCIES_CONSTANTS); + + if (constantsDependencies == null) { + + // no dependency found + return Collections.emptySet(); + } + + ObjectModelClassifier classifier = constantsDependencies.getSupplier(); + + if (!(classifier instanceof ObjectModelEnumeration)) { + + // do not have an enumeration + return Collections.emptySet(); + } + + Set<String> constantNames = new HashSet<String>(); + ObjectModelEnumeration constants = + (ObjectModelEnumeration) classifier; + + // add all literal of dependency as constants in interface + Collection<String> literals = constants.getLiterals(); + for (String literal : literals) { + + // always use builder method to obtain constant name to not use a + // possible altered by transformer + String constantName = getConstantName(literal); + + addConstant(output, + constantName, + String.class, + "\"" + literal + "\"", + ObjectModelModifier.PUBLIC + ); + constantNames.add(constantName); + } + + return constantNames; + } + + public String getConstantPrefix() { + return constantPrefix; + } + + public void setConstantPrefix(String constantPrefix) { + this.constantPrefix = constantPrefix; + } }