[Jaxx-commits] r2176 - trunk/jaxx-compiler/src/main/java/jaxx/compiler/java

26 Jan 2011

Author: tchemit
Date: 2011-01-26 15:38:37 +0100 (Wed, 26 Jan 2011)
New Revision: 2176

Url: http://nuiton.org/repositories/revision/jaxx/2176

Log:
Evolution #1236: Can generate annotations on fields or methods
Reformat the java package code


Modified:
   trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaArgument.java
   trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaElement.java
   trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaField.java
   trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFile.java
   trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFileGenerator.java
   trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaMethod.java

Modified: trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaArgument.java
===================================================================

--- trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaArgument.java	2011-01-26 14:23:12 UTC (rev 2175)
+++ trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaArgument.java	2011-01-26 14:38:37 UTC (rev 2176)
@@ -33,6 +33,7 @@
 public class JavaArgument extends JavaElement {
 
     private String type;
+
     private boolean isFinal;
 
     /**

Modified: trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaElement.java
===================================================================
--- trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaElement.java	2011-01-26 14:23:12 UTC (rev 2175)
+++ trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaElement.java	2011-01-26 14:38:37 UTC (rev 2176)
@@ -28,9 +28,9 @@
 import org.apache.commons.collections.CollectionUtils;
 
 import java.lang.reflect.Modifier;
-import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -52,7 +52,7 @@
      *
      * @since 2.3
      */
-    private List<String> annotations;
+    private Set<String> annotations;
 
     public JavaElement(int modifiers, String name) {
         this.modifiers = modifiers;
@@ -83,9 +83,9 @@
         }
     }
 
-    public List<String> getAnnotations() {
+    public Set<String> getAnnotations() {
         if (annotations == null) {
-            annotations = new ArrayList<String>();
+            annotations = new HashSet<String>();
         }
         return annotations;
     }

Modified: trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaField.java
===================================================================
--- trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaField.java	2011-01-26 14:23:12 UTC (rev 2175)
+++ trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaField.java	2011-01-26 14:38:37 UTC (rev 2176)
@@ -103,10 +103,6 @@
         return override;
     }
 
-//    public void setOverride(boolean override) {
-//        this.override = override;
-//    }
-
     public String getInitializer() {
         return initializer;
     }
@@ -118,39 +114,42 @@
 
     @Override
     public String toString() {
-        return super.toString() + " " + getName() + ", type:" + getType() + ", modifiers:" + Modifier.toString(getModifiers());
+        return super.toString() + " " + getName() + ", type:" +
+               getType() + ", modifiers:" + Modifier.toString(getModifiers());
     }
 
     public enum FieldOrder {
 
-        staticsBean(Modifier.STATIC | Modifier.PUBLIC, "Constants for all javaBean properties") {
-
+        staticsBean(Modifier.STATIC | Modifier.PUBLIC,
+                    "Constants for all javaBean properties") {
             @Override
             public boolean accept(JavaField field) {
                 return field.getName().startsWith("PROPERTY_");
-//                return field.getName().startsWith("PROPERTY_") && Modifier.isPublic(field.getModifiers());
             }
         },
 
-        staticsPublicBindings(Modifier.STATIC | Modifier.PUBLIC, "Constants for all public bindings") {
-
+        staticsPublicBindings(Modifier.STATIC | Modifier.PUBLIC,
+                              "Constants for all public bindings") {
             @Override
             public boolean accept(JavaField field) {
-                return field.getName().startsWith("BINDING_") && Modifier.isPublic(field.getModifiers());
+                return field.getName().startsWith("BINDING_") &&
+                       Modifier.isPublic(field.getModifiers());
             }
         },
 
-        staticsPrivateBindings(Modifier.STATIC | Modifier.PRIVATE, "Constants for all none public bindings") {
-
+        staticsPrivateBindings(Modifier.STATIC | Modifier.PRIVATE,
+                               "Constants for all none public bindings") {
             @Override
             public boolean accept(JavaField field) {
-                return field.getName().startsWith("BINDING_$") && Modifier.isPrivate(field.getModifiers());
+                return field.getName().startsWith("BINDING_$") &&
+                       Modifier.isPrivate(field.getModifiers());
             }
         },
 
         staticsOthers(Modifier.STATIC, "Other static fields"),
 
-        internalFields(Modifier.PROTECTED | Modifier.PRIVATE, "Internal states") {
+        internalFields(Modifier.PROTECTED | Modifier.PRIVATE,
+                       "Internal states") {
 
             private final List<String> fields = Arrays.asList(
                     "delegateContext",
@@ -209,22 +208,30 @@
                     return o;
                 }
             }
-            throw new IllegalArgumentException("could not find a " + FieldOrder.class + " for method " + method);
+            throw new IllegalArgumentException(
+                    "could not find a " + FieldOrder.class +
+                    " for method " + method);
         }
     }
 
     public static EnumMap<FieldOrder, List<JavaField>> getSortedFields(List<JavaField> fields) {
 
-        EnumMap<FieldOrder, List<JavaField>> result = new EnumMap<FieldOrder, List<JavaField>>(FieldOrder.class);
+        EnumMap<FieldOrder, List<JavaField>> result =
+                new EnumMap<FieldOrder, List<JavaField>>(FieldOrder.class);
         for (FieldOrder fieldOrder : FieldOrder.values()) {
             result.put(fieldOrder, new ArrayList<JavaField>());
         }
 
         EnumSet<FieldOrder> allConstants = EnumSet.allOf(FieldOrder.class);
         List<JavaField> allFields = new ArrayList<JavaField>(fields);
-        int[] scopes = new int[]{Modifier.STATIC, Modifier.PUBLIC, Modifier.PROTECTED, Modifier.PRIVATE};
+        int[] scopes = new int[]{Modifier.STATIC,
+                                 Modifier.PUBLIC,
+                                 Modifier.PROTECTED,
+                                 Modifier.PRIVATE
+        };
         for (int scope : scopes) {
-            EnumSet<FieldOrder> constants = getFieldOrderScope(allConstants, scope);
+            EnumSet<FieldOrder> constants =
+                    getFieldOrderScope(allConstants, scope);
 
             Iterator<JavaField> itMethods = allFields.iterator();
             while (itMethods.hasNext()) {

Modified: trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFile.java
===================================================================
--- trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFile.java	2011-01-26 14:23:12 UTC (rev 2175)
+++ trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFile.java	2011-01-26 14:38:37 UTC (rev 2176)
@@ -27,9 +27,15 @@
 
 import jaxx.compiler.types.TypeManager;
 import org.apache.commons.lang.StringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 /**
  * A Java source file being generated for output.  Once the class is completely initialized, use the
@@ -37,30 +43,53 @@
  */
 public class JavaFile extends JavaElement {
 
+    /** Logger */
+    static Log log = LogFactory.getLog(JavaFile.class);
+
     protected static final String GETTER_PATTERN = "return %1$s;";
+
     protected static final String BOOLEAN_GETTER_PATTERN = "return %1$s !=null && %1$s;";
+
     protected static final String SETTER_PATTERN = "%1$s oldValue = this.%2$s;\nthis.%2$s = newValue;\nfirePropertyChange(%3$s, oldValue, newValue);";
+
     private Set<String> imports = new HashSet<String>();
+
     private List<JavaField> fields = new ArrayList<JavaField>();
+
     private List<JavaMethod> methods = new ArrayList<JavaMethod>();
+
     private List<JavaFile> innerClasses = new ArrayList<JavaFile>();
+
     private String superClass;
+
     private List<String> interfaces;
+
     private StringBuffer rawBodyCode = new StringBuffer();
+
     private boolean superclassIsJAXXObject;
+
     private boolean abstractClass;
+
     private String genericType;
+
     private String superGenericType;
 
     public JavaFile() {
-        super(0, "");
+        this(0, "");
     }
 
+    public JavaFile(int modifiers, String className) {
+        super(modifiers, className);
+    }
+
     public JavaFile(int modifiers, String className, String superClass) {
         this(modifiers, className, superClass, null);
     }
 
-    public JavaFile(int modifiers, String className, String superClass, List<String> interfaces) {
+    public JavaFile(int modifiers,
+                    String className,
+                    String superClass,
+                    List<String> interfaces) {
         super(modifiers, className);
         this.superClass = superClass;
         this.interfaces = interfaces;
@@ -112,36 +141,72 @@
     }
 
     public void addField(JavaField field) {
+
         addField(field, false);
     }
 
+    public JavaMethod addGetterMethod(String id,
+                                      int modifiers,
+                                      String type,
+                                      boolean overridde,
+                                      boolean useOverride) {
+
+        String capitalizedName = StringUtils.capitalize(id);
+        String methodName = "get" + capitalizedName;
+        String bodyCode;
+        if (useOverride) {
+            bodyCode = "super." + methodName + "()";
+        } else {
+            bodyCode = id;
+        }
+        String content = String.format(GETTER_PATTERN, bodyCode);
+        JavaMethod method = JavaFileGenerator.newMethod(modifiers,
+                                                        type,
+                                                        methodName,
+                                                        content,
+                                                        overridde
+        );
+        addMethod(method);
+        return method;
+    }
+
     public void addField(JavaField field, boolean javaBean) {
         addSimpleField(field);
         String id = field.getName();
         String capitalizedName = StringUtils.capitalize(id);
-        // add getter file
-        String content = String.format(GETTER_PATTERN, id);
-        addMethod(new JavaMethod(
-                Modifier.isProtected(field.getModifiers()) ? Modifier.PUBLIC : Modifier.PROTECTED,
-                field.getType(), "get" + capitalizedName, null, null, content, field.isOverride()));
 
+        // add accessor method
+        int modifiers = Modifier.isProtected(field.getModifiers()) ?
+                        Modifier.PUBLIC : Modifier.PROTECTED;
+
+        addGetterMethod(id,
+                        modifiers,
+                        field.getType(),
+                        field.isOverride(),
+                        false
+        );
+
         if (javaBean) {
-            // add full javabean support accessor + mutator + constante with name of property to make it easier to use
-            // compute the property constante
+            // add full javabean support accessor + mutator + constant with
+            // name of property to make it easier to use
+            // compute the property constant
             String constantId = TypeManager.convertVariableNameToConstantName("property" + capitalizedName);
             addSimpleField(JavaFileGenerator.newField(Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL, String.class.getSimpleName(), constantId, false, "\"" + id + "\""));
 
             if (Boolean.class.getName().equals(field.getType())) {
-                content = String.format(BOOLEAN_GETTER_PATTERN, id);
+                String content = String.format(BOOLEAN_GETTER_PATTERN, id);
                 addMethod(new JavaMethod(Modifier.PUBLIC, field.getType(), "is" + capitalizedName, null, null, content, field.isOverride()));
             }
-            content = String.format(SETTER_PATTERN, field.getType(), id, constantId);
+            String content = String.format(SETTER_PATTERN, field.getType(), id, constantId);
             JavaArgument arg = new JavaArgument(field.getType(), "newValue");
             addMethod(new JavaMethod(Modifier.PUBLIC, "void", "set" + capitalizedName, new JavaArgument[]{arg}, null, content, field.isOverride()));
         }
     }
 
     public void addSimpleField(JavaField field) {
+        if (log.isDebugEnabled()) {
+            log.debug("[" + getName() + "] Add field " + field.getName());
+        }
         fields.add(field);
     }
 

Modified: trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFileGenerator.java
===================================================================
--- trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFileGenerator.java	2011-01-26 14:23:12 UTC (rev 2175)
+++ trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaFileGenerator.java	2011-01-26 14:38:37 UTC (rev 2176)
@@ -29,6 +29,7 @@
 import jaxx.compiler.java.JavaMethod.MethodOrder;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.nuiton.util.StringUtil;
 
 import java.io.PrintWriter;
 import java.util.Arrays;
@@ -48,20 +49,57 @@
     /** Logger */
     static private final Log log = LogFactory.getLog(JavaFileGenerator.class);
 
-    public static JavaField newField(int modifiers, String returnType, String name, boolean override) {
+    public static JavaField newField(int modifiers,
+                                     String returnType,
+                                     String name,
+                                     boolean override) {
         return newField(modifiers, returnType, name, override, null);
     }
 
-    public static JavaField newField(int modifiers, String returnType, String name, boolean override, String initializer) {
-        return new JavaField(modifiers, returnType, name, override, initializer);
+    public static JavaField newField(int modifiers,
+                                     String returnType,
+                                     String name,
+                                     boolean override,
+                                     String initializer) {
+        return new JavaField(modifiers,
+                             returnType,
+                             name,
+                             override,
+                             initializer
+        );
     }
 
-    public static JavaMethod newMethod(int modifiers, String returnType, String name, String initializer, boolean override, String[] exceptions, JavaArgument... arguments) {
-        return new JavaMethod(modifiers, returnType, name, arguments, exceptions, initializer, override);
+    public static JavaMethod newMethod(int modifiers,
+                                       String returnType,
+                                       String name,
+                                       String initializer,
+                                       boolean override,
+                                       String[] exceptions,
+                                       JavaArgument... arguments) {
+        return new JavaMethod(modifiers,
+                              returnType,
+                              name,
+                              arguments,
+                              exceptions,
+                              initializer,
+                              override
+        );
     }
 
-    public static JavaMethod newMethod(int modifiers, String returnType, String name, String initializer, boolean override, JavaArgument... arguments) {
-        return newMethod(modifiers, returnType, name, initializer, override, new String[0], arguments);
+    public static JavaMethod newMethod(int modifiers,
+                                       String returnType,
+                                       String name,
+                                       String initializer,
+                                       boolean override,
+                                       JavaArgument... arguments) {
+        return newMethod(modifiers,
+                         returnType,
+                         name,
+                         initializer,
+                         override,
+                         StringUtil.EMPTY_STRING_ARRAY,
+                         arguments
+        );
     }
 
     public static String getHeader(String header) {
@@ -77,7 +115,9 @@
 
         String eol = JAXXCompiler.getLineSeparator();
 
-        return all + eol + "/*--" + new String(prefix) + " " + header + " " + new String(prefix) + "--*/" + eol + all + eol;
+        return all + eol + "/*--" + new String(prefix) +
+               " " + header + " " + new String(prefix) + "--*/" + eol + all +
+               eol;
     }
 
     /** End of line */
@@ -99,12 +139,15 @@
     }
 
     public void generateFile(JavaFile f, PrintWriter result) {
+        String name = f.getName();
         if (verbose) {
-            log.info(f.getName());
+            log.info(name);
         }
         indentationLevel = 0;
-        if (f.getName().indexOf(".") != -1) {
-            result.append("package ").append(f.getName().substring(0, f.getName().lastIndexOf("."))).append(";");
+        if (name.contains(".")) {
+            result.append("package ");
+            result.append(name.substring(0, name.lastIndexOf(".")));
+            result.append(";");
             result.append(eol).append(eol);
         }
         String[] imports = f.getImports();
@@ -119,10 +162,10 @@
     }
 
     public String generateClass(JavaFile f) {
-
         if (verbose) {
             log.info(f.getName());
         }
+
         StringBuffer result = new StringBuffer();
         String genericType = f.getGenericType();
 
@@ -156,8 +199,11 @@
 
         if (!fields.isEmpty()) {
 
-            EnumMap<JavaField.FieldOrder, List<JavaField>> map = JavaField.getSortedFields(fields);
-            for (Entry<JavaField.FieldOrder, List<JavaField>> entry : map.entrySet()) {
+            EnumMap<JavaField.FieldOrder, List<JavaField>> map =
+                    JavaField.getSortedFields(fields);
+            for (Entry<JavaField.FieldOrder, List<JavaField>> entry :
+                    map.entrySet()) {
+
                 List<JavaField> list = entry.getValue();
 
                 // sort fields
@@ -166,7 +212,11 @@
                 if (!list.isEmpty()) {
 
                     // add field group header
-                    result.append(eol).append(addIndentation(entry.getKey().getHeader(), 4, eol)).append(eol).append(eol);
+                    result.append(eol);
+                    result.append(
+                            addIndentation(entry.getKey().getHeader(), 4, eol));
+                    result.append(eol);
+                    result.append(eol);
 
                     // add all fields of group
                     for (JavaField method : list) {
@@ -185,7 +235,9 @@
         StringBuffer rawBodyCode = f.getRawBodyCode();
 
         if (rawBodyCode.length() > 0) {
-            result.append(addIndentation(getHeader("Raw body code from script"), 4, eol)).append(eol);
+            result.append(addIndentation(
+                    getHeader("Raw body code from script"), 4, eol));
+            result.append(eol);
             String s = rawBodyCode.toString();
             if (!s.startsWith(eol)) {
                 result.append(eol);
@@ -200,7 +252,9 @@
             indentationLevel += 4;
             try {
                 String txt = generateClass(innerClass);
-                result.append(addIndentation(txt, 4, eol)).append(eol).append(eol);
+                result.append(addIndentation(txt, 4, eol));
+                result.append(eol);
+                result.append(eol);
             } finally {
                 indentationLevel -= 4;
             }
@@ -208,7 +262,8 @@
 
         // generate methods
 
-        EnumMap<MethodOrder, List<JavaMethod>> map = JavaMethod.getSortedMethods(f.getMethods());
+        EnumMap<MethodOrder, List<JavaMethod>> map =
+                JavaMethod.getSortedMethods(f.getMethods());
         for (Entry<MethodOrder, List<JavaMethod>> entry : map.entrySet()) {
             List<JavaMethod> list = entry.getValue();
             if (!list.isEmpty()) {
@@ -217,12 +272,16 @@
                 Collections.sort(list);
 
                 // add method group header
-                result.append(addIndentation(entry.getKey().getHeader(), 4, eol)).append(eol).append(eol);
+                result.append(addIndentation(entry.getKey().getHeader(), 4, eol));
+                result.append(eol);
+                result.append(eol);
 
                 // add all methods of group
                 for (JavaMethod method : list) {
                     String txt = generateMethod(method);
-                    result.append(addIndentation(txt, 4, eol)).append(eol).append(eol);
+                    result.append(addIndentation(txt, 4, eol));
+                    result.append(eol);
+                    result.append(eol);
                 }
             }
             list.clear();
@@ -269,8 +328,9 @@
 
         StringBuffer result = new StringBuffer();
         if (m.isOverride()) {
-            result.append("@Override").append(eol);
+            m.addAnnotation(Override.class.getSimpleName());
         }
+        generateAnnotations(m, result, eol);
         result.append(m.getModifiersText());
         if (m.getReturnType() != null) {
             result.append(m.getReturnType());
@@ -322,11 +382,20 @@
         return argument.isFinal() ? "final " + result : result;
     }
 
-    public String addIndentation(String source, int indentation, String lineSeparator) {
-        return indent(source, indentationLevel + indentation, false, lineSeparator);
+    public String addIndentation(String source,
+                                 int indentation,
+                                 String lineSeparator) {
+        return indent(source,
+                      indentationLevel + indentation,
+                      false,
+                      lineSeparator
+        );
     }
 
-    public static String indent(String source, int indentation, boolean trim, String lineSeparator) {
+    public static String indent(String source,
+                                int indentation,
+                                boolean trim,
+                                String lineSeparator) {
         if (trim) {
             source = source.trim();
         }

Modified: trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaMethod.java
===================================================================
--- trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaMethod.java	2011-01-26 14:23:12 UTC (rev 2175)
+++ trunk/jaxx-compiler/src/main/java/jaxx/compiler/java/JavaMethod.java	2011-01-26 14:38:37 UTC (rev 2176)
@@ -26,7 +26,13 @@
 package jaxx.compiler.java;
 
 import java.lang.reflect.Modifier;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.List;
 
 /**
  * Represents a method in a Java source file being generated for output.  <code>JavaMethods</code> are created
@@ -36,25 +42,19 @@
  */
 public class JavaMethod extends JavaElement implements Comparable<JavaMethod> {
 
-    /**
-     * return type of the method (null for constructors)
-     */
+    /** return type of the method (null for constructors) */
     private String returnType;
-    /**
-     * arguments of the method (can be empty)
-     */
+
+    /** arguments of the method (can be empty) */
     private JavaArgument[] arguments;
-    /**
-     * exceptions thrown by the method( can be empty)
-     */
+
+    /** exceptions thrown by the method( can be empty) */
     private String[] exceptions;
-    /**
-     * body of the mehotd (can be empty)
-     */
+
+    /** body of the mehotd (can be empty) */
     private String body;
-    /**
-     * flag to known if the method overrids a super-method
-     */
+
+    /** flag to known if the method overrids a super-method */
     private boolean override;
 
     /**
@@ -71,7 +71,13 @@
      * @param bodyCode   Java source code which should appear in the method body
      * @param override   flag with {@code true} value when the method overrides (or implements) a super class method
      */
-    public JavaMethod(int modifiers, String returnType, String name, JavaArgument[] arguments, String[] exceptions, String bodyCode, boolean override) {
+    public JavaMethod(int modifiers,
+                      String returnType,
+                      String name,
+                      JavaArgument[] arguments,
+                      String[] exceptions,
+                      String bodyCode,
+                      boolean override) {
         super(modifiers, name);
         this.returnType = returnType;
         this.override = override;
@@ -81,7 +87,8 @@
     }
 
     /**
-     * Returns the method's return type, as it would be represented in Java source code.
+     * Returns the method's return type, as it would be represented
+     * in Java source code.
      *
      * @return the method's return type
      */
@@ -125,7 +132,6 @@
         statics(Modifier.STATIC, "Statics methods"),
 
         constructors(Modifier.PUBLIC, "Constructors") {
-
             @Override
             public boolean accept(JavaMethod method) {
                 return method.returnType == null;
@@ -164,7 +170,8 @@
         },
         JAXXValidation(Modifier.PUBLIC, "JAXXValidation implementation") {
 
-            private final List<String> methods = Arrays.asList("getValidator", "getValidatorIds");
+            private final List<String> methods =
+                    Arrays.asList("getValidator", "getValidatorIds");
 
             @Override
             public boolean accept(JavaMethod method) {
@@ -172,44 +179,44 @@
             }
         },
         events(Modifier.PUBLIC, "Event methods") {
-
             @Override
             public boolean accept(JavaMethod method) {
-                return method.getName().startsWith("do") && method.getName().contains("__");
+                return method.getName().startsWith("do") &&
+                       method.getName().contains("__");
             }
         },
         publicGetters(Modifier.PUBLIC, "Public acessor methods") {
-
             @Override
             public boolean accept(JavaMethod method) {
-                return method.getName().startsWith("get") || method.getName().startsWith("is");
+                return method.getName().startsWith("get") ||
+                       method.getName().startsWith("is");
             }
         },
         publicSetters(Modifier.PUBLIC, "Public mutator methods") {
-
             @Override
             public boolean accept(JavaMethod method) {
                 return method.getName().startsWith("set");
             }
         },
         otherPublic(Modifier.PUBLIC, "Public mutator methods") {
-
             @Override
             public boolean accept(int mod) {
                 return super.accept(mod) && !Modifier.isStatic(mod);
             }
         },
         protectedGetters(Modifier.PROTECTED, "Protected acessors methods") {
-
             @Override
             public boolean accept(JavaMethod method) {
-                return method.getName().startsWith("get") || method.getName().startsWith("is");
+                return method.getName().startsWith("get") ||
+                       method.getName().startsWith("is");
             }
         },
-        createMethod(Modifier.PROTECTED | Modifier.PRIVATE, "Components creation methods") {
+        createMethod(Modifier.PROTECTED | Modifier.PRIVATE,
+                     "Components creation methods") {
             @Override
             public boolean accept(JavaMethod method) {
-                return method.getName().startsWith("create") || method.getName().startsWith("add");
+                return method.getName().startsWith("create") ||
+                       method.getName().startsWith("add");
             }
         },
         internalMethod(Modifier.PRIVATE, "Internal jaxx methods") {
@@ -217,6 +224,7 @@
                     "$completeSetup",
                     "$registerDefaultBindings",
                     "$initialize");
+
             @Override
             public boolean accept(JavaMethod method) {
                 return methods.contains(method.getName());
@@ -225,14 +233,17 @@
         protecteds(Modifier.PROTECTED, "Other protected methods") {
         },
         packageLocal(0, "Package methods") {
-
             @Override
             public boolean accept(int mod) {
-                return !Modifier.isStatic(mod) && !Modifier.isPublic(mod) && !Modifier.isProtected(mod);
+                return !Modifier.isStatic(mod) &&
+                       !Modifier.isPublic(mod) &&
+                       !Modifier.isProtected(mod);
             }
         },
         privates(Modifier.PRIVATE, "Other private methods");
+
         private final String header;
+
         private int modifier;
 
         MethodOrder(int modifier, String header) {
@@ -262,22 +273,30 @@
                     return o;
                 }
             }
-            throw new IllegalArgumentException("could not find a " + MethodOrder.class + " for method " + method);
+            throw new IllegalArgumentException(
+                    "could not find a " + MethodOrder.class +
+                    " for method " + method);
         }
     }
 
     public static EnumMap<MethodOrder, List<JavaMethod>> getSortedMethods(List<JavaMethod> methods) {
 
-        EnumMap<MethodOrder, List<JavaMethod>> result = new EnumMap<MethodOrder, List<JavaMethod>>(MethodOrder.class);
+        EnumMap<MethodOrder, List<JavaMethod>> result =
+                new EnumMap<MethodOrder, List<JavaMethod>>(MethodOrder.class);
         for (MethodOrder methodOrder : MethodOrder.values()) {
             result.put(methodOrder, new ArrayList<JavaMethod>());
         }
 
         EnumSet<MethodOrder> allConstants = EnumSet.allOf(MethodOrder.class);
         List<JavaMethod> allMethods = new ArrayList<JavaMethod>(methods);
-        int[] scopes = new int[]{Modifier.STATIC, Modifier.PUBLIC, Modifier.PROTECTED, Modifier.PRIVATE};
+        int[] scopes = new int[]{Modifier.STATIC,
+                                 Modifier.PUBLIC,
+                                 Modifier.PROTECTED,
+                                 Modifier.PRIVATE
+        };
         for (int scope : scopes) {
-            EnumSet<MethodOrder> constants = getMethodOrderScope(allConstants, scope);
+            EnumSet<MethodOrder> constants =
+                    getMethodOrderScope(allConstants, scope);
 
             Iterator<JavaMethod> itMethods = allMethods.iterator();
             while (itMethods.hasNext()) {
@@ -294,7 +313,9 @@
         }
 
         if (!allMethods.isEmpty()) {
-            throw new IllegalArgumentException("could not find a " + MethodOrder.class + " for method " + allMethods);
+            throw new IllegalArgumentException(
+                    "could not find a " + MethodOrder.class +
+                    " for method " + allMethods);
         }
 
         for (MethodOrder methodOrder : MethodOrder.values()) {

    

[Jaxx-commits] r2176 - trunk/jaxx-compiler/src/main/java/jaxx/compiler/java

tchemit＠users.nuiton.org