r671 - in branches/1.1.0-Javabuilder: eugene eugene/src/main/java/org/nuiton/eugene eugene/src/main/java/org/nuiton/eugene/java eugene-test eugene-test/src/main/java/org/nuiton/eugene/test/generator - Eugene-commits

29 Oct 2009

Author: fdesbois
Date: 2009-10-29 19:53:26 +0100 (Thu, 29 Oct 2009)
New Revision: 671

Added:
   branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/
   branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaBuilder.java
   branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaGenerator.java
   branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java
Modified:
   branches/1.1.0-Javabuilder/eugene-test/pom.xml
   branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/test/generator/BeanTransformer.java
   branches/1.1.0-Javabuilder/eugene/pom.xml
Log:
- Change position of classes specific for Java generation
- Add processor plugin to parse JavaGenerator template

Modified: branches/1.1.0-Javabuilder/eugene/pom.xml
===================================================================

--- branches/1.1.0-Javabuilder/eugene/pom.xml	2009-10-29 18:53:22 UTC (rev 670)
+++ branches/1.1.0-Javabuilder/eugene/pom.xml	2009-10-29 18:53:26 UTC (rev 671)
@@ -233,6 +233,26 @@
                         </configuration>
                     </plugin>
 
+                    <plugin>
+                        <groupId>org.nuiton.processor</groupId>
+                        <artifactId>maven-processor-plugin</artifactId>
+                        <version>${processor.version}</version>
+                        <executions>
+                            <execution>
+                                <phase>generate-sources</phase>
+                                <goals>
+                                    <goal>process</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <includes>org/nuiton/eugene/java/JavaGenerator.java</includes>
+                            <filters>
+                                org.nuiton.processor.filters.GeneratorTemplatesFilter
+                            </filters>
+                        </configuration>
+                    </plugin>
+
                 </plugins>
             </build>
         </profile>

Copied: branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaBuilder.java (from rev 669, branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/JavaBuilder.java)
===================================================================
--- branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaBuilder.java	                        (rev 0)
+++ branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaBuilder.java	2009-10-29 18:53:26 UTC (rev 671)
@@ -0,0 +1,326 @@
+package org.nuiton.eugene.java;
+
+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.*;
+import org.nuiton.eugene.models.object.xml.*;
+
+/**
+ * JavaBuilder
+ * <p/>
+ * Created: 29 oct. 2009
+ *
+ * @author fdesbois
+ * @version $Revision$
+ *
+ * Mise a jour: $Date$
+ * par : $Author$
+ * <p/>
+ */
+public class JavaBuilder {
+
+    private static final Log log = LogFactory.getLog(JavaBuilder.class);
+
+    protected ObjectModelImpl model;
+
+    public JavaBuilder(String modelName) {
+        this.model = new ObjectModelImpl();
+        this.model.setName(modelName);
+    }
+
+    public ObjectModel getModel() {
+        return this.model;
+    }
+
+    protected ImportsManager getImportsManager(ObjectModelClassifier classifier) {
+        ImportsManager manager = model.getExtension(classifier.getQualifiedName(), ImportsManager.class);
+        if (manager == null) {
+            manager = new ImportsManager();
+            model.addExtension(classifier.getQualifiedName(), manager);
+            if (log.isDebugEnabled()) {
+                log.debug("Add new importsManager for : " + classifier.getQualifiedName());
+            }
+        }
+        return manager;
+    }
+
+    /*protected void addImportForClassifier(ObjectModelClassifier classifier, String imports) {
+        ImportsManager manager = getImportsManager(classifier);
+        manager.addImport(imports);
+    }
+
+    protected void addImportForClassifier(ObjectModelClassifier classifier, Class<?> imports) {
+        ImportsManager manager = getImportsManager(classifier);
+        manager.addImport(imports);
+    }*/
+
+    public 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);
+            }
+        }
+    }
+
+    public ObjectModelClass createClass(String name, String packageName) {
+        ObjectModelClassImpl clazz =
+                (ObjectModelClassImpl)ObjectModelBuilderHelper.createClass(name, packageName);
+        model.addClass(clazz);
+        return clazz;
+    }
+
+    public ObjectModelClass createAbstractClass(String name, String packageName) {
+        ObjectModelClassImpl clazz =
+                (ObjectModelClassImpl)ObjectModelBuilderHelper.createAbstractClass(name, packageName);
+        model.addClass(clazz);
+        return clazz;
+    }
+
+    public void setSuperClass(ObjectModelClass classifier, String superclassQualifiedName) {
+        ObjectModelClassImpl impl = (ObjectModelClassImpl) classifier;
+        impl.getSuperclasses().clear(); // suppress all existing superclass: only one can be set for java
+        ObjectModelBuilderHelper.addSuperclass(impl, superclassQualifiedName);
+        this.addImport(classifier, superclassQualifiedName);
+    }
+
+    public void addInterface(ObjectModelClassifier classifier, String interfaceQualifiedName) {
+        ObjectModelBuilderHelper.addInterface(classifier, interfaceQualifiedName);
+        this.addImport(classifier, interfaceQualifiedName);
+    }
+
+    /**
+     * 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
+     * @return a new ObjectModelAttribute corresponding to the new attribute added to the classifier
+     * @throws IllegalArgumentException 
+     */
+    public ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, String parse)
+            throws IllegalArgumentException {
+        ObjectModelAttributeImpl attribute = new ObjectModelAttributeImpl();
+        String result = parse;
+        try {
+            // Visibility
+            if (parse.contains("public ")) {
+                attribute.setVisibility("public");
+                result = parse.replace("public ", "");
+            } else if (parse.contains("protected ")) {
+                attribute.setVisibility("protected");
+                result = parse.replace("protected ", "");
+            } else if (parse.contains("private ")) {
+                attribute.setVisibility("private");
+                result = parse.replace("private ", "");
+            } else {
+                attribute.setVisibility("");
+            }
+
+            // Static
+            if (result.contains("static ")) {
+                attribute.setStatic(true);
+                result = result.replace("static ", "");
+            }
+            // Final
+            if (result.contains("final ")) {
+                attribute.setFinal(true);
+                result = result.replace("final ", "");
+            }
+
+            // Type
+            int typeIndex = result.indexOf(" ");
+            String type = result.substring(0, typeIndex).trim();
+            attribute.setType(type);
+            result = result.substring(typeIndex + 1);
+
+            // Name
+            int nameIndex = result.indexOf("=");
+            String name = "";
+            if (nameIndex != -1) {
+                name = result.substring(0, nameIndex).trim();
+                result = result.substring(nameIndex);
+
+                // DefaultValue
+                int equalsIndex = result.indexOf("=");
+                String value = result.substring(equalsIndex + 1).trim();
+                attribute.setDefaultValue(value);
+
+                //if (value.contains("new ")) {
+                    this.addImport(classifier, value);
+                //}
+
+            } else { // Il ne reste que le nom si pas de =
+                name = result;
+            }
+            attribute.setName(name);
+
+            ObjectModelClassifierImpl classifierImpl = (ObjectModelClassifierImpl) classifier;
+            classifierImpl.addAttribute(attribute);
+            this.addImport(classifier, attribute.getType());
+        } catch (StringIndexOutOfBoundsException eee) {
+            throw new IllegalArgumentException("Can't add Attribute : Illegal parse parameter : " +
+                    "input = " + parse + " _ current = " + result, eee);
+        }
+        return attribute;
+    }
+
+    public ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, ObjectModelAttribute attribute) {
+        this.addImport(classifier, attribute.getType());
+        return ObjectModelBuilderHelper.addAttribute(classifier, attribute.getName(), attribute.getType(),
+                attribute.getDefaultValue(), attribute.getVisibility(), attribute.isStatic(), attribute.isFinal());
+    }
+
+    public ObjectModelOperation addConstructor(ObjectModelClass clazz, String visibility) {
+        return ObjectModelBuilderHelper.addOperation(clazz, visibility, clazz.getName(), null);
+    }
+
+    /**
+     * Attention ne marche pas pour les constructeur !!!
+     * Attention ne marche pas pour les generic du type :  <T extends Plop> T myMethod !!!
+     * @param classifier
+     * @param parse
+     * @return
+     * @throws IllegalArgumentException
+     */
+    public ObjectModelOperation addOperation(ObjectModelClassifier classifier, String parse)
+            throws IllegalArgumentException {
+        ObjectModelOperationImpl operation = new ObjectModelOperationImpl();
+        String result = "";
+
+        try {
+            // Visibility
+            if (parse.contains("public ")) {
+                operation.setVisibility("public");
+                result = parse.replace("public ", "");
+            } else if (parse.contains("protected ")) {
+                operation.setVisibility("protected");
+                result = parse.replace("protected ", "");
+            } else if (parse.contains("private ")) {
+                operation.setVisibility("private");
+                result = parse.replace("private ", "");
+            } else {
+                operation.setVisibility("");
+            }
+
+            // Static
+            if (result.contains("static ")) {
+                operation.setStatic(true);
+                result = result.replace("static ", "");
+            }
+            // Abstract
+            if (result.contains("abstract ")) {
+                operation.setAbstract(true);
+                result = result.replace("abstract ", "");
+            }
+
+            // Return Parameter
+            int typeIndex = result.indexOf(" ");
+            String type = result.substring(0, typeIndex).trim();
+            result = result.substring(typeIndex + 1);
+
+             // TROP COMPLEXE pour les generic du type <T extends Plop> T myMethod
+            /*if (log.isDebugEnabled()) {
+                log.debug ("type : " + type + " _ result= " + result);
+            }
+            if (type.contains("<")) { // Generic : <T extends Plop> T myMethod
+                int endGeneric = result.indexOf(">"); // index de fin du generic
+                type += result.substring(0, endGeneric).trim(); // type = <T extends Plop>
+                if (log.isDebugEnabled()) {
+                    log.debug ("type : " + type + " _ result= " + result);
+                }
+                result = result.substring(endGeneric + 1).trim(); // result = T myMethod
+                if (log.isDebugEnabled()) {
+                    log.debug ("type : " + type + " _ result= " + result);
+                }
+                typeIndex = result.indexOf(" ");
+                type += " " + result.substring(0, typeIndex).trim(); // type = <T extends Plop> T
+                if (log.isDebugEnabled()) {
+                    log.debug ("type : " + type + " _ result= " + result);
+                }
+                result = result.substring(typeIndex + 1); // result = myMethod
+                if (log.isDebugEnabled()) {
+                    log.debug ("type : " + type + " _ result= " + result);
+                }
+            }*/
+            ObjectModelParameterImpl returnParameter = new ObjectModelParameterImpl();
+            returnParameter.setType(type);
+            operation.setReturnParameter(returnParameter);
+
+            if (log.isDebugEnabled()) {
+                log.debug("parse before name : " + result);
+            }
+
+            int nameIndex = result.indexOf("(");
+            String methodName = "";
+            if (nameIndex != -1) {
+                methodName = result.substring(0, nameIndex).trim();
+                result = result.substring(nameIndex);
+
+                // Input parameters
+                if (result.contains("(")) {
+                    int parentheseIndex = result.indexOf("(");
+                    int parentheseEndIndex = result.indexOf(")");
+                    result = result.substring(parentheseIndex + 1, parentheseEndIndex);
+
+                    String paramName = "";
+                    for (String param : result.split(",")) {
+                        typeIndex = param.indexOf(" ");
+                        type = param.substring(0, typeIndex).trim();
+                        paramName = param.substring(typeIndex + 1).trim();
+
+                        ObjectModelParameterImpl parameter = new ObjectModelParameterImpl();
+                        parameter.setType(type);
+                        parameter.setName(paramName);
+                        operation.addParameter(parameter);
+                    }
+                }
+
+            } else { // Il ne reste que le nom si pas de (
+                methodName = result;
+            }
+            operation.setName(methodName);
+
+            // Add operation to Classifier
+            ObjectModelClassifierImpl classifierImpl = (ObjectModelClassifierImpl) classifier;
+            classifierImpl.addOperation(operation);
+            // imports for returnType
+            this.addImport(classifier, operation.getReturnType());
+            // imports for inputParameters
+            for (ObjectModelParameter parameter : operation.getParameters()) {
+                this.addImport(classifier, parameter.getType());
+            }
+        } catch (StringIndexOutOfBoundsException eee) {
+            throw new IllegalArgumentException("Can't add Operation : Illegal parse parameter : " +
+                    "input = " + parse + " _ current = " + result, eee);
+        }
+        return operation;
+    }
+
+    public ObjectModelOperation addOperation(ObjectModelClassifier classifier, String visibility,
+            String type, String name, String... inputParameters) {
+
+        return ObjectModelBuilderHelper.addOperation(classifier, visibility, name, type, inputParameters);
+    }
+
+    public ObjectModelParameter addParameter(ObjectModelOperation operation, String type, String name) {
+        ObjectModelParameter param = ObjectModelBuilderHelper.addParameter(operation, type, name);
+        this.addImport((ObjectModelClassifier) operation.getDeclaringElement(), type);
+        return param;
+    }
+
+    public void addException(ObjectModelOperation operation, String exception) {
+        ObjectModelBuilderHelper.addException(operation, exception);
+        this.addImport((ObjectModelClassifier) operation.getDeclaringElement(), exception);
+    }
+
+    public void setOperationBody(ObjectModelOperation operation, String body) {
+        ObjectModelBuilderHelper.setOperationBody(operation, body);
+    }
+
+
+}


Property changes on: branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaBuilder.java
___________________________________________________________________
Added: svn:mergeinfo
   + 

Copied: branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaGenerator.java (from rev 668, branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/JavaGenerator.java)
===================================================================
--- branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaGenerator.java	                        (rev 0)
+++ branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/JavaGenerator.java	2009-10-29 18:53:26 UTC (rev 671)
@@ -0,0 +1,203 @@
+
+package org.nuiton.eugene.java;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+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.ObjectModelGenerator;
+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;
+
+/**
+ * JavaGenerator
+ *
+ * Created: 22 oct. 2009
+ *
+ * @author fdesbois
+ * @version $Revision$
+ *
+ * Mise a jour: $Date$
+ * par : $Author$
+ */
+public class JavaGenerator extends ObjectModelGenerator {
+
+    private static final Log log = LogFactory.getLog(JavaGenerator.class);
+
+    @Override
+    public String getFilenameForClass(ObjectModelClass clazz) {
+        return clazz.getQualifiedName().replace('.', File.separatorChar) + ".java";//return clazz.getName() + ".java";
+    }
+
+    @Override
+    public void generateFromClass(Writer output, ObjectModelClass clazz) throws IOException {
+
+        if (log.isInfoEnabled()) {
+            log.info("generate : " + clazz.getName());
+        }
+
+        this.generateHeader(output, clazz); // Imports, package et documentation
+
+        String abstractStr = clazz.isAbstract() ? " abstract " : " ";
+        String className = clazz.getName();
+        
+        String extend = "";
+        Iterator<ObjectModelClass> j = clazz.getSuperclasses().iterator();
+        if (j.hasNext()) {
+            ObjectModelClassifier p = j.next();
+            extend += GeneratorUtil.getSimpleName(p.getQualifiedName());
+        }
+
+        String implement = "";
+        for (Iterator<ObjectModelInterface> i = clazz.getInterfaces().iterator(); i.hasNext();) {
+            ObjectModelClassifier parentInterface = i.next();
+            implement += GeneratorUtil.getSimpleName(parentInterface.getQualifiedName());
+            if (i.hasNext()) {
+                implement += ", ";
+            }
+        }
+
+/*{
+public<%=abstractStr%>class <%=className%>}*/
+
+/*
+ * Définition de la super classe : il ne doit y avoir qu'une
+ */
+        if (extend.length() > 0) {
+/*{ extends <%=extend%>}*/
+        }
+
+        if (implement.length() > 0) {
+/*{ implements <%=implement%> {
+
+}*/
+        } else {
+        	/*{ {
+
+}*/
+        }
+
+        this.generateAttributes(output, clazz.getAttributes());
+        this.generateOperations(output, clazz.getOperations());
+/*{
+} //<%=clazz.getName()%>
+}*/
+    }
+
+    protected void generateHeader(Writer output, ObjectModelClassifier classifier) throws IOException {
+
+        String packageName = classifier.getPackageName();
+/*{package <%=packageName%>;
+
+}*/
+        // potentiel crash si imports non defini
+        // dans ce cas, probleme de config utilisateur ! obligation de passer par un builder ?
+        ImportsManager manager = getModel().getExtension(classifier.getQualifiedName(), ImportsManager.class);
+        for (String imports : manager.getImports(classifier.getPackageName())) {
+/*{import <%=imports%>;
+ }*/
+        }
+
+    }
+
+    protected void generateAttributes(Writer output, Collection<ObjectModelAttribute> attributes) throws IOException {
+
+        for (ObjectModelAttribute attr : attributes) {
+
+            if (attr.getDocumentation() != null && !attr.getDocumentation().isEmpty()) {
+/*{    /**
+     * <%=attr.getDocumentation()%>
+     *)
+}*/
+            }
+
+//            String annotation = attr.getTagValue(TAG_ANNOTATION);
+//            if (annotation != null && annotation.length() > 0) {
+///*    <%=annotation%>
+//*/
+//            }
+
+            String attrName = attr.getName();
+            String attrVisibility = attr.getVisibility();
+            String attrType = GeneratorUtil.getSimpleName(attr.getType());
+            String attrStatic = attr.isStatic() ? " static" : "";
+            String attrFinal = attr.isFinal() ? " final" : "";
+            String attrValue = attr.getDefaultValue() != null && !attr.getDefaultValue().isEmpty() ?
+                " = " + GeneratorUtil.getSimpleName(attr.getDefaultValue()) : "";
+
+/*{    <%=attrVisibility%><%=attrStatic%><%=attrFinal%> <%=attrType%> <%=attrName%><%=attrValue%>;
+}*/
+        }
+    }
+
+    protected void generateOperations(Writer output, Collection<ObjectModelOperation> operations) throws IOException {
+        for (ObjectModelOperation op : operations) {
+        	String opName = op.getName();
+/*{    /**
+}*/
+            if (op.getDocumentation() != null && !op.getDocumentation().isEmpty()) {
+            	String opDocumentation = op.getDocumentation();
+/*{     * <%=opName%> : <%=opDocumentation%>
+}*/
+            }
+            Collection<ObjectModelParameter> params = op.getParameters();
+            for (ObjectModelParameter param : params) {
+            	String paramName = param.getName();
+            	String paramDocumentation = param.getDocumentation();
+/*{     * @param <%=paramName%> <%=paramDocumentation%>
+ }*/
+            }
+            String opVisibility = op.getVisibility();
+            String opStatic = op.isStatic() ? "static " : "";
+            String opAbstract = op.isAbstract() ? "abstract " : "";
+            
+            ObjectModelParameter returnParam = op.getReturnParameter();
+            String opReturn = "";
+            if (returnParam != null) {
+                opReturn = GeneratorUtil.getSimpleName(returnParam.getType()) + " ";
+                if (!opReturn.equals("void")) {
+                    String paramDocumentation = returnParam.getDocumentation();
+/*{     * @return <%=paramDocumentation%>
+ }*/
+                }
+            }
+/*{    *)
+    <%=opVisibility%> <%=opStatic%><%=opAbstract%><%=opReturn%><%=opName%>(}*/
+            String comma = "";
+            for (ObjectModelParameter param : params) {
+            	String paramName = param.getName();
+            	String paramType = GeneratorUtil.getSimpleName(param.getType());
+/*{<%=comma%><%=paramType%> <%=paramName%>}*/
+                comma = ", ";
+            }
+/*{)}*/
+            Set<String> exceptions = op.getExceptions();
+            comma = " throws ";
+            for (String exception : exceptions) {
+/*{<%=comma%><%=exception%>}*/
+                comma = ", ";
+            }
+
+            if (!op.getBodyCode().isEmpty()) {
+/*{ {<%=op.getBodyCode()%>}
+
+}*/
+            } else {
+/*{;
+
+}*/
+            }
+        }
+    }
+    
+}

Copied: branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java (from rev 669, branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/java/OM2JavaTransformer.java)
===================================================================
--- branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java	                        (rev 0)
+++ branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java	2009-10-29 18:53:26 UTC (rev 671)
@@ -0,0 +1,111 @@
+package org.nuiton.eugene.java;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.nuiton.eugene.ImportsManager;
+import org.nuiton.eugene.ObjectModelTransformer;
+import org.nuiton.eugene.models.object.*;
+
+/**
+ * OM2JavaTransformer
+ * <p/>
+ * Created: 28 oct. 2009
+ *
+ * @author fdesbois
+ * @version $Revision$
+ *          <p/>
+ *          Mise a jour: $Date$
+ *          par : $Author$
+ */
+public abstract class ObjectModelTransformerToJava extends ObjectModelTransformer<ObjectModel> {
+
+    private static final Log log = LogFactory.getLog(ObjectModelTransformerToJava.class);
+
+    private JavaBuilder builder;
+
+    public ObjectModelTransformerToJava() {
+        super(new JavaGenerator());
+    }
+
+    @Override
+    protected ObjectModel initOutputModel() {
+        if (log.isInfoEnabled()) {
+            log.debug("inputModelName = " + getModel().getName());
+        }
+        this.builder = new JavaBuilder(getModel().getName());
+        this.outputModel = builder.getModel();
+        return this.outputModel;
+    }
+
+    @Override
+    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());
+                }
+            }
+        }
+    }
+
+    protected ObjectModelClass createClass(String name, String packageName) {
+        return builder.createClass(name, packageName);
+    }
+
+    protected ObjectModelClass createAbstractClass(String name, String packageName) {
+        return builder.createAbstractClass(name, packageName);
+    }
+
+    protected void setSuperClass(ObjectModelClass classifier, String superclassQualifiedName) {
+        builder.setSuperClass(classifier, superclassQualifiedName);
+    }
+
+    protected void addInterface(ObjectModelClassifier classifier, String interfaceQualifiedName) {
+        builder.addInterface(classifier, interfaceQualifiedName);
+    }
+
+    protected ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, String parse)
+            throws IllegalArgumentException {
+        return builder.addAttribute(classifier, parse);
+    }
+
+    protected ObjectModelAttribute addAttribute(ObjectModelClassifier classifier, ObjectModelAttribute attribute) {
+        return builder.addAttribute(classifier, attribute);
+    }
+
+    protected ObjectModelOperation addConstructor(ObjectModelClass clazz, String visibility) {
+        return builder.addConstructor(clazz, visibility);
+    }
+
+    protected ObjectModelOperation addOperation(ObjectModelClassifier classifier, String parse)
+            throws IllegalArgumentException {
+        return builder.addOperation(classifier, parse);
+    }
+
+    protected ObjectModelOperation addOperation(ObjectModelClassifier classifier, String visibility,
+            String type, String name, String... inputParameters) {
+        return builder.addOperation(classifier, visibility, type, name, inputParameters);
+    }
+
+    protected ObjectModelParameter addParameter(ObjectModelOperation operation, String type, String name) {
+        return builder.addParameter(operation, type, name);
+    }
+
+    protected void addException(ObjectModelOperation operation, String exception) {
+        builder.addException(operation, exception);
+    }
+
+    protected void setOperationBody(ObjectModelOperation operation, String body) {
+        builder.setOperationBody(operation, body);
+    }
+
+}


Property changes on: branches/1.1.0-Javabuilder/eugene/src/main/java/org/nuiton/eugene/java/ObjectModelTransformerToJava.java
___________________________________________________________________
Added: svn:mergeinfo
   + 

Modified: branches/1.1.0-Javabuilder/eugene-test/pom.xml
===================================================================
--- branches/1.1.0-Javabuilder/eugene-test/pom.xml	2009-10-29 18:53:22 UTC (rev 670)
+++ branches/1.1.0-Javabuilder/eugene-test/pom.xml	2009-10-29 18:53:26 UTC (rev 671)
@@ -82,8 +82,7 @@
                     <configuration>
                         <includes>**/*.java</includes>
                         <filters>
-                            org.nuiton.processor.filters.GeneratorTemplatesFilter,
-                            org.nuiton.processor.filters.ActiveLogsCodeFilter
+                            org.nuiton.processor.filters.GeneratorTemplatesFilter
                         </filters>
                     </configuration>
                 </plugin>

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-29 18:53:22 UTC (rev 670)
+++ branches/1.1.0-Javabuilder/eugene-test/src/main/java/org/nuiton/eugene/test/generator/BeanTransformer.java	2009-10-29 18:53:26 UTC (rev 671)
@@ -2,7 +2,7 @@
 
 import org.apache.commons.lang.StringUtils;
 import org.nuiton.eugene.GeneratorUtil;
-import org.nuiton.eugene.java.OM2JavaTransformer;
+import org.nuiton.eugene.java.ObjectModelTransformerToJava;
 import org.nuiton.eugene.models.object.*;
 
 import java.beans.PropertyChangeListener;
@@ -26,7 +26,7 @@
  *          Mise a jour: $Date$
  *          par : $Author$
  */
-public class BeanTransformer extends OM2JavaTransformer {
+public class BeanTransformer extends ObjectModelTransformerToJava {
 
     public BeanTransformer() {
         super();

    

r671 - in branches/1.1.0-Javabuilder: eugene eugene/src/main/java/org/nuiton/eugene eugene/src/main/java/org/nuiton/eugene/java eugene-test eugene-test/src/main/java/org/nuiton/eugene/test/generator

fdesbois＠users.nuiton.org

tags

participants (1)