Author: fdesbois Date: 2009-10-29 14:32:03 +0100 (Thu, 29 Oct 2009) New Revision: 667 Modified: branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/JavaBuilderHelper.java branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/OM2JavaTransformer.java branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/test/generator/BeanTransformer.java branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java Log: - Correct errors for outputModel - Correct some errors in helper - Correct problem with importsManager Modified: branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java =================================================================== --- branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java 2009-10-28 19:04:40 UTC (rev 666) +++ branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/ObjectModelTransformer.java 2009-10-29 13:32:03 UTC (rev 667) @@ -1,40 +1,34 @@ - package org.nuiton.eugene; -import org.nuiton.eugene.*; +import org.nuiton.eugene.models.Model; +import org.nuiton.eugene.models.object.*; + import java.io.File; import java.util.Collection; -import org.nuiton.eugene.models.Model; -import org.nuiton.eugene.models.object.ObjectModel; -import org.nuiton.eugene.models.object.ObjectModelClass; -import org.nuiton.eugene.models.object.ObjectModelClassifier; -import org.nuiton.eugene.models.object.ObjectModelElement; -import org.nuiton.eugene.models.object.ObjectModelEnumeration; -import org.nuiton.eugene.models.object.ObjectModelInterface; /** * ObjectModelTransformer - * + * <p/> * Created: 28 oct. 2009 * - * @param <O> * @author fdesbois * @version $Revision$ - * - * Mise a jour: $Date$ - * par : $Author$ + * <p/> + * Mise a jour: $Date$ + * par : $Author$ + * @param <O> */ -public abstract class ObjectModelTransformer<O extends Model> extends Transformer<ObjectModel, O>{ +public abstract class ObjectModelTransformer<O extends Model> extends Transformer<ObjectModel, O> { public ObjectModelTransformer(Generator<O> output) { super(output); } protected abstract O initOutputModel(); - + /** * Par defaut la methode appelle la methode - * {@link #generateFromModel(Writer, ObjectModel)} puis boucle sur chaque + * {@link #transformFromModel(ObjectModel)} puis boucle sur chaque * class en appelant la m?thode * {@link #generateFromClass(Writer, ObjectModelClass)} puis boucle sur chaque * interface en appelant a méthode @@ -45,9 +39,11 @@ * getFilenameFor.... La methode generateFrom... n'utilise pas le Writer * alors le fichier n'est pas généré, si on l'utilise m?me pour ne rien * écrire alors le fichier sera généré. + * * @param model * @param destDir - */@Override + */ + @Override public void generate(ObjectModel model, File destDir) { // generateFromModel @@ -55,20 +51,20 @@ initOutputModel(); //try { - //String filename = getFilenameForModel(model); - transformFromElement(model, ObjectModelType.OBJECT_MODEL); + //String filename = getFilenameForModel(model); + transformFromElement(model, ObjectModelType.OBJECT_MODEL); - // generateFromClassifier - transformFromElements(model.getClassifiers(), ObjectModelType.OBJECT_MODEL_CLASSIFIER); + // generateFromClassifier + transformFromElements(model.getClassifiers(), ObjectModelType.OBJECT_MODEL_CLASSIFIER); - // generateFromInterface - transformFromElements(model.getInterfaces(), ObjectModelType.OBJECT_MODEL_INTERFACE); + // generateFromInterface + transformFromElements(model.getInterfaces(), ObjectModelType.OBJECT_MODEL_INTERFACE); - // generateFromClass - transformFromElements(model.getClasses(), ObjectModelType.OBJECT_MODEL_CLASS); + // generateFromClass + transformFromElements(model.getClasses(), ObjectModelType.OBJECT_MODEL_CLASS); - // generateFromEnumeration - transformFromElements(model.getEnumerations(), ObjectModelType.OBJECT_MODEL_ENUMERATION); + // generateFromEnumeration + transformFromElements(model.getEnumerations(), ObjectModelType.OBJECT_MODEL_ENUMERATION); /*} catch (IOException eee) { if (log.isWarnEnabled()) { @@ -76,9 +72,13 @@ } }*/ + debugOutputModel(); + outputGenerator.generate(getOutputModel(), destDir); } + protected abstract void debugOutputModel(); + /** * Parcours une collection d'éléments pour la génération suivant un type d'éléments. * Types possibles : ObjectModelClassifier, ObjectModelClass, ObjectModelInterface et @@ -86,27 +86,29 @@ * Deux méthodes dépendent du type et peuvent être surchargées : * getFilenameForXXX et generateFromXXX (XXX étant un type prédéfini pour une méthode existante). * + * @param elements Collection d'éléments d'un des types ci-dessus + * @param destDir dossier de destination pour le fichier généré + * @param type type explicite d'ObjectModel * @see ObjectModelType - * - * @param elements Collection d'éléments d'un des types ci-dessus - * @param destDir dossier de destination pour le fichier généré - * @param type type explicite d'ObjectModel */ private void transformFromElements(Collection<? extends ObjectModelElement> elements, - ObjectModelType type) { + ObjectModelType type) { for (ObjectModelElement element : elements) { String filename = ""; // Filename depends on type of element (Classifier, Class, Interface or Enumeration) switch (type) { case OBJECT_MODEL_CLASSIFIER: - filename = getFilenameForClassifier((ObjectModelClassifier)element); break; + filename = getFilenameForClassifier((ObjectModelClassifier) element); + break; case OBJECT_MODEL_INTERFACE: - filename = getFilenameForInterface((ObjectModelInterface)element); break; + filename = getFilenameForInterface((ObjectModelInterface) element); + break; case OBJECT_MODEL_CLASS: - filename = getFilenameForClass((ObjectModelClass)element); break; + filename = getFilenameForClass((ObjectModelClass) element); + break; case OBJECT_MODEL_ENUMERATION: - filename = getFilenameForEnumeration((ObjectModelEnumeration)element); + filename = getFilenameForEnumeration((ObjectModelEnumeration) element); } transformFromElement(element, type); @@ -119,38 +121,38 @@ * ObjectModelInterface et ObjectModelEnumeration. * La méthode generateFromXXX dépend du type d'élément et peut être surchargée. * + * @param element element à généré + * @param destDir dossier de destination + * @param filename nom du fichier de sortie + * @param type type d'ObjectModel * @see ObjectModelType - * - * @param element element à généré - * @param destDir dossier de destination - * @param filename nom du fichier de sortie - * @param type type d'ObjectModel */ protected void transformFromElement(Object element, ObjectModelType type) { - switch (type) { - case OBJECT_MODEL: - transformFromModel((ObjectModel)element); - break; - case OBJECT_MODEL_CLASSIFIER: - transformFromClassifier((ObjectModelClassifier)element); - break; - case OBJECT_MODEL_INTERFACE: - transformFromInterface((ObjectModelInterface)element); - break; - case OBJECT_MODEL_CLASS: - transformFromClass((ObjectModelClass)element); - break; - case OBJECT_MODEL_ENUMERATION: - transformFromEnumeration((ObjectModelEnumeration)element); - break; - } + switch (type) { + case OBJECT_MODEL: + transformFromModel((ObjectModel) element); + break; + case OBJECT_MODEL_CLASSIFIER: + transformFromClassifier((ObjectModelClassifier) element); + break; + case OBJECT_MODEL_INTERFACE: + transformFromInterface((ObjectModelInterface) element); + break; + case OBJECT_MODEL_CLASS: + transformFromClass((ObjectModelClass) element); + break; + case OBJECT_MODEL_ENUMERATION: + transformFromEnumeration((ObjectModelEnumeration) element); + break; + } } /** * Par defaut cette methode retourne le getName du model. Si l'on souhaite * utiliser la methode generateFromModel il vaut mieux surcharger cette * methode + * * @param model * @return */ @@ -161,6 +163,7 @@ /** * Par defaut cette methode retourne le QualifiedName convertie en chemin * par exemple pour org.codelutin.Toto on aurait org/codelutin/Toto + * * @param model * @param packageName * @return @@ -172,6 +175,7 @@ /** * Par defaut cette methode retourne le QualifiedName convertie en chemin * par exemple pour org.codelutin.Toto on aurait org/codelutin/Toto + * * @param interfacez * @return */ @@ -182,6 +186,7 @@ /** * Par defaut cette methode retourne le QualifiedName convertie en chemin * par exemple pour org.codelutin.Toto on aurait org/codelutin/Toto + * * @param clazz * @return */ @@ -192,6 +197,7 @@ /** * Par defaut cette methode retourne le QualifiedName convertie en chemin * par exemple pour org.codelutin.Toto on aurait org/codelutin/Toto + * * @param clazz * @return */ Modified: branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/JavaBuilderHelper.java =================================================================== --- branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/JavaBuilderHelper.java 2009-10-28 19:04:40 UTC (rev 666) +++ branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/JavaBuilderHelper.java 2009-10-29 13:32:03 UTC (rev 667) @@ -1,29 +1,23 @@ - package org.nuiton.eugene.java; 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.xml.ObjectModelBuilderHelper; import org.nuiton.eugene.models.object.ObjectModelClass; import org.nuiton.eugene.models.object.ObjectModelClassifier; import org.nuiton.eugene.models.object.ObjectModelOperation; -import org.nuiton.eugene.models.object.xml.ObjectModelAttributeImpl; -import org.nuiton.eugene.models.object.xml.ObjectModelClassImpl; -import org.nuiton.eugene.models.object.xml.ObjectModelClassifierImpl; -import org.nuiton.eugene.models.object.xml.ObjectModelOperationImpl; -import org.nuiton.eugene.models.object.xml.ObjectModelParameterImpl; +import org.nuiton.eugene.models.object.xml.*; /** * JavaBuilderHelper - * + * <p/> * Created: 28 oct. 2009 * * @author fdesbois * @version $Revision$ - * - * Mise a jour: $Date$ - * par : $Author$ + * <p/> + * Mise a jour: $Date$ + * par : $Author$ */ public class JavaBuilderHelper extends ObjectModelBuilderHelper { @@ -33,8 +27,9 @@ * Add attribute to a classifier with properties in parse string. * Use java syntax to define properties of the attribute : * ex : "public static final java.util.Date maDate = new java.util.Date()" + * * @param classifier the classifier to add the attribute - * @param parse the properties of the attribute to parse + * @param parse the properties of the attribute to parse * @return a new ObjectModelAttribute corresponding to the new attribute added to the classifier */ public ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, String parse) { @@ -69,7 +64,7 @@ int typeIndex = parse.indexOf(" "); String type = parse.substring(0, typeIndex).trim(); attribute.setType(type); - parse = parse.substring(typeIndex+1); + parse = parse.substring(typeIndex + 1); // Name int nameIndex = parse.indexOf("="); @@ -80,7 +75,7 @@ // DefaultValue int equalsIndex = parse.indexOf("="); - String value = parse.substring(equalsIndex+1).trim(); + String value = parse.substring(equalsIndex + 1).trim(); attribute.setDefaultValue(value); } else { // Il ne reste que le nom si pas de = @@ -88,13 +83,13 @@ } attribute.setName(name); - ObjectModelClassifierImpl classifierImpl = (ObjectModelClassifierImpl)classifier; + ObjectModelClassifierImpl classifierImpl = (ObjectModelClassifierImpl) classifier; classifierImpl.addAttribute(attribute); return attribute; } public ObjectModelOperation addOperation(ObjectModelClassifier classifier, String parse) - throws IllegalArgumentException{ + throws IllegalArgumentException { ObjectModelOperationImpl operation = new ObjectModelOperationImpl(); String result = ""; @@ -183,11 +178,14 @@ impl.setFinal(attribute.isFinal()); impl.setStatic(attribute.isStatic()); impl.setDefaultValue(attribute.getDefaultValue()); + + ObjectModelClassifierImpl classifierImpl = (ObjectModelClassifierImpl) classifier; + classifierImpl.addAttribute(impl); return impl; } public void setSuperClass(ObjectModelClass classifier, String superclassQualifiedName) { - ObjectModelClassImpl impl = (ObjectModelClassImpl)classifier; + ObjectModelClassImpl impl = (ObjectModelClassImpl) classifier; impl.getSuperclasses().clear(); addSuperclass(impl, superclassQualifiedName); } @@ -197,7 +195,7 @@ operation.setVisibility(visibility); operation.setName(clazz.getName()); - ObjectModelClassImpl classifierImpl = (ObjectModelClassImpl)clazz; + ObjectModelClassImpl classifierImpl = (ObjectModelClassImpl) clazz; classifierImpl.addOperation(operation); return operation; } Modified: branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/OM2JavaTransformer.java =================================================================== --- branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/OM2JavaTransformer.java 2009-10-28 19:04:40 UTC (rev 666) +++ branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/OM2JavaTransformer.java 2009-10-29 13:32:03 UTC (rev 667) @@ -1,39 +1,31 @@ - package org.nuiton.eugene.java; -import org.nuiton.eugene.ObjectModelTransformer; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.ImportsManager; -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.ObjectModelOperation; -import org.nuiton.eugene.models.object.ObjectModelParameter; +import org.nuiton.eugene.ObjectModelTransformer; +import org.nuiton.eugene.models.object.*; import org.nuiton.eugene.models.object.xml.ObjectModelClassImpl; import org.nuiton.eugene.models.object.xml.ObjectModelImpl; /** * OM2JavaTransformer - * + * <p/> * Created: 28 oct. 2009 * * @author fdesbois * @version $Revision$ - * - * Mise a jour: $Date$ - * par : $Author$ + * <p/> + * Mise a jour: $Date$ + * par : $Author$ */ public class OM2JavaTransformer extends ObjectModelTransformer<ObjectModel> { private static final Log log = LogFactory.getLog(OM2JavaTransformer.class); - protected ObjectModelImpl outputModel; + private static JavaBuilderHelper helper = new JavaBuilderHelper(); - private static JavaBuilderHelper helper = new JavaBuilderHelper(); - public OM2JavaTransformer() { super(new JavaGenerator()); this.outputModel = new ObjectModelImpl(); @@ -42,31 +34,51 @@ @Override protected ObjectModel initOutputModel() { if (log.isInfoEnabled()) { - log.info("inputModelName = " + getModel().getName()); + log.debug("inputModelName = " + getModel().getName()); } - outputModel.setName(getModel().getName()); - return outputModel; + ObjectModelImpl impl = (ObjectModelImpl) getOutputModel(); + impl.setName(getModel().getName()); + return impl; } @Override - public ObjectModel getOutputModel() { - return this.outputModel; + protected void debugOutputModel() { + if (log.isDebugEnabled()) { + log.debug("classes : " + getOutputModel().getClasses().size()); + for (ObjectModelClass clazz : getOutputModel().getClasses()) { + log.debug(" class : " + clazz.getQualifiedName()); + ImportsManager manager = getOutputModel().getExtension(clazz.getQualifiedName(), ImportsManager.class); + for (String imports : manager.getImports(clazz.getPackageName())) { + log.debug(" import : " + imports); + } + for (ObjectModelAttribute attribute : clazz.getAttributes()) { + log.debug(" attribute : " + attribute.getType() + " " + attribute.getName()); + } + for (ObjectModelOperation operation : clazz.getOperations()) { + log.debug(" operation : " + operation.getReturnType() + " " + operation.getName()); + } + } + } } public JavaBuilderHelper getHelper() { return helper; } - + protected ImportsManager getImportsManager(ObjectModelClassifier classifier) { - ImportsManager manager = outputModel.getExtension(classifier.getQualifiedName(), ImportsManager.class); + ObjectModelImpl impl = (ObjectModelImpl) getOutputModel(); + ImportsManager manager = impl.getExtension(classifier.getQualifiedName(), ImportsManager.class); if (manager == null) { manager = new ImportsManager(); - outputModel.addExtension(classifier.getQualifiedName(), manager); + impl.addExtension(classifier.getQualifiedName(), manager); + if (log.isDebugEnabled()) { + log.debug("Add new importsManager for : " + classifier.getQualifiedName()); + } } return manager; } - protected void addImportForClassifier(ObjectModelClassifier classifier, String imports) { + /*protected void addImportForClassifier(ObjectModelClassifier classifier, String imports) { ImportsManager manager = getImportsManager(classifier); manager.addImport(imports); } @@ -74,48 +86,30 @@ protected void addImportForClassifier(ObjectModelClassifier classifier, Class<?> imports) { ImportsManager manager = getImportsManager(classifier); manager.addImport(imports); + }*/ + + protected ObjectModelClass createClass(String name, String packageName) { + ObjectModelClassImpl clazz = new ObjectModelClassImpl(); + clazz.setName(name); + clazz.setPackage(packageName); + ObjectModelImpl impl = (ObjectModelImpl) getOutputModel(); + impl.addClass(clazz); + return clazz; } - protected void addClassToModel(ObjectModelClass clazz) { - outputModel.addClass((ObjectModelClassImpl)clazz); - //ImportsManager manager = setImports(clazz); - - // extension for superclass - /*Iterator<ObjectModelClass> it = clazz.getSuperclasses().iterator(); - if (it.hasNext()) { - ObjectModelClass superclass = it.next(); - manager.addImport(superclass.getQualifiedName()); - }*/ + protected ObjectModelClass createAbstractClass(String name, String packageName) { + ObjectModelClassImpl clazz = (ObjectModelClassImpl) createClass(name, packageName); + clazz.setAbstract(true); + return clazz; } - /*private ImportsManager setImports(ObjectModelClassifier classifier) { - ImportsManager manager = getImportsManager(classifier); - // attributes - for (ObjectModelAttribute attribute : classifier.getAttributes()) { - if (log.isInfoEnabled()) { - log.info("attribute add import for : " + attribute.getType()); - } - setImportsForType(manager, attribute.getType()); - setImportsForType(manager, attribute.getDefaultValue()); - } - // implemented interfaces - for (ObjectModelInterface interfacez : classifier.getInterfaces()) { - manager.addImport(interfacez.getQualifiedName()); - } - // operations - for (ObjectModelOperation operation : classifier.getOperations()) { - setImportsForType(manager, operation.getReturnType()); - for (ObjectModelParameter parameter : operation.getParameters()) { - setImportsForType(manager, parameter.getType()); - } - } - return manager; - }*/ - private void addImport(ObjectModelClassifier classifier, String imports) { ImportsManager manager = getImportsManager(classifier); for (String oneType : GeneratorUtil.getTypesList(imports)) { manager.addImport(oneType); + if (log.isDebugEnabled()) { + log.debug("Add import for : " + classifier.getQualifiedName() + " _ import: " + oneType); + } } } @@ -128,7 +122,7 @@ getHelper().addInterface(classifier, interfaceQualifiedName); addImport(classifier, interfaceQualifiedName); } - + protected ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, String parse) { ObjectModelAttribute attribute = getHelper().addAttribute(classifier, parse); addImport(classifier, attribute.getType()); @@ -136,26 +130,34 @@ } protected ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, ObjectModelAttribute attribute) { - getHelper().addAttribute(classifier, attribute); - addImport(classifier, attribute.getType()); - return attribute; + ObjectModelAttribute result = getHelper().addAttribute(classifier, attribute); + if (log.isDebugEnabled()) { + log.debug("add attribute : " + result.getVisibility() + " " + result.getType() + " " + result.getName()); + } + addImport(classifier, result.getType()); + return result; } protected ObjectModelOperation addOperation(ObjectModelClassifier classifier, String parse) { ObjectModelOperation operation = getHelper().addOperation(classifier, parse); + // imports for returnType addImport(classifier, operation.getReturnType()); + // imports for inputParameters + for (ObjectModelParameter parameter : operation.getParameters()) { + addImport(classifier, parameter.getType()); + } return operation; } protected ObjectModelParameter addParameter(ObjectModelOperation operation, String type, String name) { ObjectModelParameter param = getHelper().addParameter(operation, type, name); - addImport((ObjectModelClassifier)operation.getDeclaringElement(), type); + addImport((ObjectModelClassifier) operation.getDeclaringElement(), type); return param; } protected void addException(ObjectModelOperation operation, String exception) { getHelper().addException(operation, exception); - addImport((ObjectModelClassifier)operation.getDeclaringElement(), exception); + addImport((ObjectModelClassifier) operation.getDeclaringElement(), exception); } } Modified: branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/test/generator/BeanTransformer.java =================================================================== --- branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/test/generator/BeanTransformer.java 2009-10-28 19:04:40 UTC (rev 666) +++ branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/test/generator/BeanTransformer.java 2009-10-29 13:32:03 UTC (rev 667) @@ -1,30 +1,27 @@ - package org.nuiton.eugene.test.generator; +import org.nuiton.eugene.GeneratorUtil; import org.nuiton.eugene.java.OM2JavaTransformer; +import org.nuiton.eugene.models.object.*; + import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; import java.io.Serializable; import java.util.Iterator; -import org.nuiton.eugene.GeneratorUtil; -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.ObjectModelInterface; -import org.nuiton.eugene.models.object.ObjectModelOperation; -import org.nuiton.eugene.models.object.ObjectModelParameter; /*{generator option: parentheses = false}*/ + /*{generator option: writeString = +}*/ /** * BeanTransformer - * + * <p/> * Created: 28 oct. 2009 * * @author fdesbois * @version $Revision$ - * - * Mise a jour: $Date$ - * par : $Author$ + * <p/> + * Mise a jour: $Date$ + * par : $Author$ */ public class BeanTransformer extends OM2JavaTransformer { @@ -39,7 +36,12 @@ return; } - ObjectModelClass resultClass = getHelper().createClass(clazz.getName(), clazz.getPackageName()); + ObjectModelClass resultClass = null; + if (!clazz.getOperations().isEmpty()) { + resultClass = this.createAbstractClass(clazz.getName(), clazz.getPackageName()); + } else { + resultClass = this.createClass(clazz.getName(), clazz.getPackageName()); + } // Set superclass Iterator<ObjectModelClass> j = clazz.getSuperclasses().iterator(); @@ -49,7 +51,7 @@ } // Add interfaces from inputModel - for (Iterator<ObjectModelInterface> i=clazz.getInterfaces().iterator(); i.hasNext();) { + for (Iterator<ObjectModelInterface> i = clazz.getInterfaces().iterator(); i.hasNext();) { ObjectModelClassifier parentInterface = i.next(); this.addInterface(resultClass, parentInterface.getQualifiedName()); } @@ -58,7 +60,7 @@ // Add attributes for (ObjectModelAttribute attr : clazz.getAttributes()) { - + if (attr.isNavigable() || attr.hasAssociationClass()) { if (GeneratorUtil.isNMultiplicity(attr)) { @@ -66,7 +68,7 @@ //type = List.class.getName(); } else { //type = Collection.class.getName(); - } + } } this.addAttribute(resultClass, attr); @@ -80,15 +82,13 @@ for (ObjectModelParameter param : op.getParameters()) { ObjectModelParameter resultParameter = this.addParameter(resultOperation, - param.getType(), param.getName()); + param.getType(), param.getName()); } for (String exception : op.getExceptions()) { this.addException(resultOperation, exception); } } - - this.addClassToModel(resultClass); } private void createForDTO(ObjectModelClass resultClass, ObjectModelClass inputClass) { @@ -104,51 +104,51 @@ protected void createListeners(ObjectModelClass resultClass, ObjectModelClass inputClass) { - this.addAttribute(resultClass, "protected final PropertyChangeSupport pcs"); + this.addAttribute(resultClass, "protected final " + PropertyChangeSupport.class.getName() + " pcs"); // Default constructor - ObjectModelOperation constructor = getHelper().addConstructor(inputClass, "public"); + ObjectModelOperation constructor = getHelper().addConstructor(resultClass, "public"); getHelper().setOperationBody(constructor, "" - /*{ - pcs = new PropertyChangeSupport(this); - }*/ + /*{ + pcs = new PropertyChangeSupport(this); + }*/ ); // Add PropertyListener String propType = PropertyChangeListener.class.getName(); String strType = String.class.getName(); - ObjectModelOperation addPropertyChangeListener = this.addOperation(inputClass, + ObjectModelOperation addPropertyChangeListener = this.addOperation(resultClass, "public void addPropertyChangeListener(" + propType + " listener)"); getHelper().setOperationBody(addPropertyChangeListener, "" - /*{ - pcs.addPropertyChangeListener(listener); - }*/ + /*{ + pcs.addPropertyChangeListener(listener); + }*/ ); - ObjectModelOperation addPropertyChangeListenerPlus =this.addOperation(inputClass, + ObjectModelOperation addPropertyChangeListenerPlus = this.addOperation(resultClass, "public void addPropertyChangeListener(" + strType + " propertyName," + propType + " listener)"); getHelper().setOperationBody(addPropertyChangeListenerPlus, "" - /*{ - pcs.addPropertyChangeListener(propertyName, listener); - }*/ + /*{ + pcs.addPropertyChangeListener(propertyName, listener); + }*/ ); - ObjectModelOperation removePropertyChangeListener = this.addOperation(inputClass, + ObjectModelOperation removePropertyChangeListener = this.addOperation(resultClass, "public void removePropertyChangeListener(" + propType + " listener)"); getHelper().setOperationBody(removePropertyChangeListener, "" - /*{ - pcs.removePropertyChangeListener(listener); - }*/ + /*{ + pcs.removePropertyChangeListener(listener); + }*/ ); - ObjectModelOperation removePropertyChangeListenerPlus =this.addOperation(inputClass, + ObjectModelOperation removePropertyChangeListenerPlus = this.addOperation(resultClass, "public void removePropertyChangeListener(" + strType + " propertyName," + propType + " listener)"); getHelper().setOperationBody(removePropertyChangeListenerPlus, "" - /*{ - pcs.removePropertyChangeListener(propertyName, listener); - }*/ + /*{ + pcs.removePropertyChangeListener(propertyName, listener); + }*/ ); } - + }