1 files changed, 157 insertions, 0 deletions
diff --git a/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ClassG.java b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ClassG.java
new file mode 100644
index 0000000..6c0e246
--- /dev/null
+++ b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ClassG.java
@@ -0,0 +1,157 @@
+package io.trygvis.container.compiler.model;
+
+import javax.lang.model.type.TypeMirror;
+import java.io.CharArrayWriter;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import static org.springframework.util.StringUtils.collectionToDelimitedString;
+
+public class ClassG {
+    private final String packageName;
+    private final String className;
+    private final String extendsClass;
+    private final Set<TypeRef> imports = new TreeSet<>();
+    private final Set<FieldRef> fields = new TreeSet<>();
+    private final List<MethodRef> methods = new ArrayList<>();
+
+//    public ClassG(String packageName, String className) {
+//        this(packageName, className, null);
+//    }
+
+    public ClassG(String packageName, String className, String extendsClass) {
+        this.packageName = packageName;
+        this.className = className;
+        this.extendsClass = extendsClass;
+    }
+
+    public TypeRef addImport(final TypeMirror type) {
+        if (type.getKind().isPrimitive()) {
+            return TypeRef.find(type.getKind());
+        }
+
+        String canonicalName = type.toString();
+        System.out.println("canonicalName = " + canonicalName);
+
+        for (TypeRef i : imports) {
+            if (i.canonicalName().equals(canonicalName)) {
+                return i;
+            }
+        }
+
+        TypeRef ref = new TypeRef(canonicalName, canonicalName);
+        imports.add(ref);
+        return ref;
+    }
+
+    public TypeRef addImport(Class<?> klass) {
+//        if (klass.isPrimitive()) {
+//            return TypeRef.PRIMITIVE;
+//        }
+
+        String canonicalName = klass.getCanonicalName();
+        String simpleName = klass.getSimpleName();
+        String name = simpleName;
+        for (TypeRef i : imports) {
+            if (i.canonicalName().equals(canonicalName)) {
+                return i;
+            }
+
+            if (i.name.equals(simpleName)) {
+                name = canonicalName;
+                break;
+            }
+        }
+
+        TypeRef ref = new TypeRef(name, canonicalName);
+        imports.add(ref);
+
+        return ref;
+    }
+
+    public FieldRef addField(Class<?> klass, String name) {
+        TypeRef type = addImport(klass);
+        FieldRef ref = new FieldRef(type, name);
+        fields.add(ref);
+        return ref;
+    }
+
+    public MethodRef addMethod(String body, TypeRef returnType, String name, ParameterRef... parameters) {
+        MethodRef ref = new MethodRef(returnType, name, parameters, body);
+        methods.add(ref);
+        return ref;
+    }
+
+    public void write(PrintWriter writer) {
+        writer.println("package " + packageName + ";");
+        writer.println();
+        for (TypeRef i : imports) {
+            if (i.isPrimitive()) {
+                continue;
+            }
+            writer.println("import " + i.canonicalName() + ";");
+        }
+        writer.println();
+        writer.println("public class " + className + " extends " + extendsClass + " {");
+        for (FieldRef field : fields) {
+            writer.println("    private final " + field.klass.name + " " + field.name + ";");
+        }
+
+        for (MethodRef method : methods) {
+            write(writer, method);
+        }
+
+        writer.println("}");
+    }
+
+    private void write(PrintWriter writer, MethodRef method) {
+        String returnString;
+        if (method.returnType == TypeRef.VOID) {
+            returnString = "void";
+        } else {
+            returnString = method.returnType.name;
+        }
+
+        List<String> parameters = new ArrayList<>();
+        for (ParameterRef p : method.parameters) {
+            parameters.add(p.klass.name + " " + p.name);
+        }
+
+        writer.println("    public " + returnString + " " + method.name + "(" + collectionToDelimitedString(parameters, ", ") + ") {");
+        writer.println(method.body);
+        writer.println("    }");
+    }
+
+    public void simpleConstructor(List<ParameterRef> parameters, List<String> goesToSuper) {
+        List<String> ps = new ArrayList<>();
+        for (ParameterRef p : parameters) {
+            ps.add(p.klass.name + " " + p.name);
+        }
+        List<String> ss = new ArrayList<>();
+        List<String> local = new ArrayList<>();
+        for (String s : goesToSuper) {
+            for (ParameterRef parameter : parameters) {
+                if (parameter.name.equals(s)) {
+                    ss.add(parameter.name);
+                    continue;
+                }
+            }
+            local.add(s);
+        }
+        String params = ps.size() == 0 ? "" : ", " + collectionToDelimitedString(ps, ", ");
+
+        CharArrayWriter buffer = new CharArrayWriter();
+        PrintWriter writer = new PrintWriter(buffer);
+
+        writer.println("    public " + className + "(" + params + ") {");
+        writer.println("        super(" + collectionToDelimitedString(ss, ", ") + ");");
+//        writer.println("        this.transactionManager = _transactionManager_;");
+        for (String s : local) {
+            writer.println("        this." + s + " = " + s);
+        }
+        writer.println("    }");
+    }
+}