diff options
Diffstat (limited to 'container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ClassG.java')
| -rw-r--r-- | container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ClassG.java | 186 |
1 files changed, 126 insertions, 60 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 index 857311d..e71bbb7 100644 --- 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 @@ -1,31 +1,60 @@ package io.trygvis.container.compiler.model; +import io.trygvis.container.compiler.Utils; +import org.apache.commons.lang.StringUtils; + +import javax.annotation.Generated; import javax.lang.model.type.TypeMirror; -import java.io.PrintWriter; import java.lang.reflect.Modifier; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.Set; import java.util.TreeSet; +import static io.trygvis.container.compiler.Utils.toJavaString; import static java.lang.reflect.Modifier.*; +import static java.util.Arrays.asList; +import static org.apache.commons.lang.StringUtils.join; import static org.springframework.util.StringUtils.collectionToDelimitedString; public class ClassG { + public final int modifiers; public final TypeRef type; - private final TypeRef extendsClass; + private TypeRef extendsType; + private List<TypeRef> implementsTypes = new ArrayList<>(); private final Set<TypeRef> imports = new TreeSet<>(); private final Set<FieldRef> fields = new TreeSet<>(); private final List<MethodRef> methods = new ArrayList<>(); private final List<Constructor> constructors = new ArrayList<>(); + private final List<InnerClassG> innerClasses = new ArrayList<>(); + + public static class InnerClassG extends ClassG { + public final ClassG parent; - public ClassG(TypeRef type) { - this(type, null); + public InnerClassG(ClassG parent, int modifiers, TypeRef type) { + super(modifiers, type); + this.parent = parent; + } } - public ClassG(TypeRef type, TypeRef extendsClass) { + public ClassG(int modifiers, TypeRef type) { + if ((Modifier.classModifiers() & modifiers) != modifiers) { + throw new RuntimeException("Invalid modifiers for class: " + Modifier.toString(modifiers)); + } + + this.modifiers = modifiers; this.type = type; - this.extendsClass = extendsClass; + } + + public ClassG extendsType(TypeRef extendsType) { + this.extendsType = extendsType; + return this; + } + + public ClassG implementsType(TypeRef... implementsTypes) { + this.implementsTypes.addAll(asList(implementsTypes)); + return this; } public TypeRef addImport(final TypeMirror type) { @@ -38,20 +67,20 @@ public class ClassG { public TypeRef addImport(TypeRef klass) { String fqName = klass.fqName; - String name = klass.name; + String name = klass.toString(); for (TypeRef i : imports) { if (i.fqName.equals(fqName)) { return i; } // If we've already found an import with the same name, use the fq version - if (i.name.equals(name)) { + if (i.plainName.equals(name)) { name = fqName; break; } } - TypeRef ref = new TypeRef(name, fqName); + TypeRef ref = new TypeRef(fqName, name); imports.add(ref); return ref; @@ -64,23 +93,23 @@ public class ClassG { return ref; } - public FieldRef addField(int modifiers, Class<?> klass, String name) { - TypeRef type = addImport(klass); - FieldRef ref = new FieldRef(modifiers, type, name); + public FieldRef addField(int modifiers, TypeRef type, String name) { + TypeRef t = addImport(type); + FieldRef ref = new FieldRef(modifiers, t, name); fields.add(ref); return ref; } - public FieldRef addField(Class<?> klass, String name) { - return addField(PRIVATE | FINAL, klass, name); + public FieldRef addField(TypeRef type, String name) { + return addField(PRIVATE | FINAL, type, name); } - public FieldRef addPublicFinalField(Class<?> klass, String name) { - return addField(PUBLIC | FINAL, klass, name); + public FieldRef addPublicFinalField(TypeRef type, String name) { + return addField(PUBLIC | FINAL, type, name); } - public FieldRef addPublicStaticFinalField(Class<?> klass, String name) { - return addField(PUBLIC | STATIC | FINAL, klass, name); + public FieldRef addPublicStaticFinalField(TypeRef type, String name) { + return addField(PUBLIC | STATIC | FINAL, type, name); } public Constructor addConstructor(Parameters parameters, List<String> body) { @@ -89,92 +118,129 @@ public class ClassG { return constructor; } - public MethodRef addMethod(List<String> body, TypeRef returnType, String name, ParameterRef... parameters) { + public MethodRef addMethod(List<String> body, TypeRef returnType, String name, Parameters parameters) { MethodRef ref = new MethodRef(PUBLIC, returnType, name, parameters, body); methods.add(ref); return ref; } - public MethodRef addStaticMethod(List<String> body, TypeRef returnType, String name, ParameterRef... parameters) { + public MethodRef addStaticMethod(List<String> body, TypeRef returnType, String name, Parameters parameters) { MethodRef ref = new MethodRef(PUBLIC | STATIC, returnType, name, parameters, body); methods.add(ref); return ref; } - public void write(PrintWriter writer) { - if (!type.inUnnamedPackage()) { - writer.println("package " + type.packageName() + ";"); - writer.println(); + public InnerClassG addInnerClass(int modifiers, TypeRef type) { + InnerClassG inner = new InnerClassG(this, modifiers, type); + innerClasses.add(inner); + return inner; + } + + public final List<String> generate() { + TypeRef generatedType = addImport(Generated.class); + + List<String> body = new ArrayList<>(); + boolean isInner = this instanceof InnerClassG; + if (!type.inUnnamedPackage() && !isInner) { + body.add("package " + type.packageName() + ";"); + body.add(""); } - for (TypeRef i : imports) { - if (i.isPrimitive() || i.inUnnamedPackage()) { - continue; + if (!isInner) { + // TODO: Add imports from inner classes + for (TypeRef i : getImports()) { + if (i.isPrimitive() || i.inUnnamedPackage()) { + continue; + } + body.add("import " + i.fqName + ";"); + } + if (!imports.isEmpty()) { + body.add(""); } - writer.println("import " + i.fqName + ";"); - } - if (!imports.isEmpty()) { - writer.println(); } - String extendsString = extendsClass == null ? "" : " extends " + extendsClass.name; + String extendsString = extendsType == null ? "" : " extends " + extendsType; + + if (!implementsTypes.isEmpty()) { + extendsString += " implements " + join(implementsTypes, ", "); + } - writer.println("public class " + type.className + extendsString + " {"); + body.add("@" + generatedType + "(" + toJavaString("SQL Persistence, yay!!") + ")"); + body.add(Modifier.toString(modifiers) + " class " + type.className + extendsString + " {"); for (FieldRef field : fields) { - writer.println(); - writer.println(" " + field.toJava() + ";"); + body.add(""); + body.add(" " + field.toJava() + ";"); + } + + for (InnerClassG innerClass : innerClasses) { + body.add(""); + addAll(1, body, innerClass.generate()); } for (Constructor constructor : constructors) { - writer.println(); - for (String s : constructor.write()) { - writer.println(s); - } + body.add(""); + addAll(1, body, constructor.write()); } for (MethodRef method : methods) { - writer.println(); - write(writer, method); + body.add(""); + addAll(1, body, write(method)); } - writer.println("}"); + body.add("}"); + return body; } - private void write(PrintWriter writer, MethodRef method) { + public static void addAll(int indent, List<String> body, List<String> innerBody) { + String prefix = StringUtils.leftPad("", indent * 4); + for (String s : innerBody) { + body.add(prefix + s); + } + } + + protected Collection<? extends TypeRef> getImports() { + List<TypeRef> imports = new ArrayList<>(this.imports); + for (InnerClassG c : innerClasses) { + imports.addAll(c.getImports()); + } + return imports; + } + + private List<String> write(MethodRef method) { + List<String> body = new ArrayList<>(); String returnString; if (method.returnType == TypeRef.VOID) { returnString = "void"; } else { - returnString = method.returnType.name; + returnString = method.returnType.toString(); } List<String> parameters = new ArrayList<>(); - for (ParameterRef p : method.parameters) { - parameters.add("final " + p.klass.name + " " + p.name); + for (Parameters.ParameterRef p : method.parameters) { + parameters.add("final " + p.klass + " " + p.name); } - writer.print(" " + - Modifier.toString(method.modifiers) + " " + + String m = Modifier.toString(method.modifiers) + " " + returnString + " " + - method.name + "(" + collectionToDelimitedString(parameters, ", ") + ")"); + method.name + "(" + collectionToDelimitedString(parameters, ", ") + ")"; if (method.exceptions.isEmpty()) { - writer.println(" {"); + body.add(m + " {"); } else { - writer.println(" throws"); ArrayList<TypeRef> typeRefs = new ArrayList<>(method.exceptions); - for (int i = 0; i < typeRefs.size(); i++) { + String end = typeRefs.size() == 1 ? " {" : ","; + body.add(m + " throws " + typeRefs.get(0).toString() + end); + for (int i = 1; i < typeRefs.size(); i++) { TypeRef e = typeRefs.get(i); - writer.print(" " + e.name); + String s = " " + e; if (i < typeRefs.size() - 1) { - writer.println(","); + s += ","; } else { - writer.println(" {"); + s += " {"; } + body.add(s); } } - for (String s : method.body) { - writer.print(" "); - writer.println(s); - } - writer.println(" }"); + addAll(1, body, method.body); + body.add("}"); + return body; } } |