write constructors for interfaces, interfaces implement all members from superinterfaces

Author: petekanev

dts-generator/src/main/java/com/telerik/dts/DtsApi.java

@@ -8,13 +8,16 @@
 import org.apache.bcel.generic.BasicType;
 import org.apache.bcel.generic.ObjectType;
 import org.apache.bcel.generic.Type;
+import org.apache.bcel.util.BCELComparator;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Queue;
 import java.util.Set;
 
 /**
@@ -34,6 +37,8 @@ public class DtsApi {
 
     public DtsApi() {
         this.indent = 0;
+
+        overrideFieldComparator();
     }
 
     public String generateDtsContent(List<JavaClass> javaClasses) {
@@ -49,6 +54,7 @@ public String generateDtsContent(List<JavaClass> javaClasses) {
 
                 JavaClass currClass = javaClasses.get(i);
                 currentFileClassname = currClass.getClassName();
+                boolean isInterface = currClass.isInterface();
 
                 this.indent = closePackage(this.prevClass, currClass);
                 this.indent = openPackage(this.prevClass, currClass);
@@ -65,19 +71,35 @@ public String generateDtsContent(List<JavaClass> javaClasses) {
                     sbContent.appendln(tabs + "export class " + getSimpleClassname(currClass) + extendsLine + " {");
                 }
                 // process member scope
-                List<FieldOrMethod> foms = getMembers(currClass);
-                for(FieldOrMethod fom : foms) {
-                    if(fom instanceof Field) {
-                        processField((Field)fom, currClass);
+
+                // process constructors for interfaces
+                if(isInterface) {
+                    List<JavaClass> allInterfaces = getAllInterfaces(currClass);
+
+                    List<Method> allInterfacesMethods = getAllInterfacesMethods(allInterfaces);
+                    Set<Field> allInterfaceFields = getAllInterfacesFields(allInterfaces);
+                    processInterfaceConstructor(currClass, allInterfacesMethods);
+
+                    for(Method m : allInterfacesMethods) {
+                        processMethod(m, currClass);
                     }
-                    else if(fom instanceof Method) {
-                        processMethod((Method)fom, currClass);
+
+                    for(Field f : allInterfaceFields) {
+                        processField(f, currClass);
                     }
-                    else {
-                        throw new IllegalArgumentException("Argument is not method or field");
+                } else {
+                    List<FieldOrMethod> foms = getMembers(currClass);
+                    for (FieldOrMethod fom : foms) {
+                        if (fom instanceof Field) {
+                            processField((Field) fom, currClass);
+                        } else if (fom instanceof Method) {
+                            processMethod((Method) fom, currClass);
+                        } else {
+                            throw new IllegalArgumentException("Argument is not method or field");
+                        }
                     }
+                    // process member scope end
                 }
-                // process member scope end
 
                 sbContent.appendln(tabs + "}");
                 if(getSimpleClassname(currClass).equals("AccessibilityDelegate")) {
@@ -207,6 +229,79 @@ private int openPackage(JavaClass prevClass, JavaClass currClass) {
         return indent;
     }
 
+    private void processInterfaceConstructor(JavaClass classInterface, List<Method> allInterfacesMethods) {
+        String tabs = getTabs(this.indent + 1);
+
+        generateInterfaceConstructorContent(classInterface, tabs, allInterfacesMethods);
+    }
+
+    private void generateInterfaceConstructorContent(JavaClass classInterface, String tabs, List<Method> methods) {
+        generateInterfaceConstructorCommentBlock(classInterface, tabs);
+
+        sbContent.appendln(tabs + "public constructor(implementation: {");
+
+        for (Method m : methods) {
+            sbContent.append(getTabs(this.indent +  2) + getMethodName(m) + getMethodParamSignature(classInterface, m));
+            String bmSig = "";
+            if (!isConstructor(m)) {
+                bmSig += ": " + getTypeScriptTypeFromJavaType(classInterface, m.getReturnType());
+            }
+            sbContent.appendln(bmSig + ";");
+        }
+
+        sbContent.appendln(tabs + "});");
+    }
+
+    private void generateInterfaceConstructorCommentBlock(JavaClass classInterface, String tabs) {
+        sbContent.appendln(tabs + "/**");
+        sbContent.appendln(tabs + " * Constructs a new instance of the " + classInterface.getClassName() + " interface with the provided implementation.");
+        sbContent.appendln(tabs + " * @param implementation - allows implementor to define their own logic for all public methods.");
+        sbContent.appendln(tabs + " */");
+    }
+
+    private List<JavaClass> getAllInterfaces(JavaClass classInterface) {
+        ArrayList<JavaClass> interfaces = new ArrayList<>();
+
+        Queue<JavaClass> classQueue = new LinkedList<>();
+        classQueue.add(classInterface);
+
+        while(!classQueue.isEmpty()) {
+            JavaClass clazz = classQueue.poll();
+
+            interfaces.add(clazz);
+
+            String[] interfaceNames = clazz.getInterfaceNames();
+
+            for(String intface : interfaceNames) {
+                JavaClass clazz1 = ClassRepo.findClass(intface);
+
+                classQueue.add(clazz1);
+            }
+        }
+
+        return interfaces;
+    }
+
+    private List<Method> getAllInterfacesMethods(List<JavaClass> interfaces) {
+        ArrayList<Method> allInterfacesMethods = new ArrayList<>();
+
+        for(JavaClass clazz : interfaces) {
+            Method[] intfaceMethods = clazz.getMethods();
+            allInterfacesMethods.addAll(Arrays.asList(intfaceMethods));
+        }
+
+        return allInterfacesMethods;
+    }
+
+    private Set<Field> getAllInterfacesFields(List<JavaClass> interfaces) {
+        HashSet<Field> allInterfacesFields = new HashSet<>();
+
+        for(JavaClass clazz : interfaces) {
+            allInterfacesFields.addAll(Arrays.asList(clazz.getFields()));
+        }
+
+        return allInterfacesFields;
+    }
     //method related
     private void processMethod(Method m, JavaClass clazz) {
 
@@ -490,4 +585,20 @@ private String getTabs(int count) {
         String tabs = new String(new char[count]).replace("\0", "\t");
         return tabs;
     }
+
+    private void overrideFieldComparator() {
+        BCELComparator cmp = Field.getComparator();
+
+        Field.setComparator(new BCELComparator() {
+            @Override
+            public boolean equals(Object o, Object o1) {
+                return ((Field)o).getName().equals(((Field) o1).getName());
+            }
+
+            @Override
+            public int hashCode(Object o) {
+                return cmp.hashCode(o);
+            }
+        });
+    }
 }