diff options
Diffstat (limited to 'container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model')
5 files changed, 298 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(" }"); + } +} diff --git a/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/FieldRef.java b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/FieldRef.java new file mode 100644 index 0000000..29a2c51 --- /dev/null +++ b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/FieldRef.java @@ -0,0 +1,31 @@ +package io.trygvis.container.compiler.model; + +public class FieldRef implements Comparable<FieldRef> { + public final TypeRef klass; + public final String name; + + public FieldRef(TypeRef klass, String name) { + this.klass = klass; + this.name = name; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof FieldRef)) return false; + + FieldRef fieldRef = (FieldRef) o; + + return name.equals(fieldRef.name); + } + + @Override + public int hashCode() { + return name.hashCode(); + } + + @Override + public int compareTo(FieldRef o) { + return name.compareTo(o.name); + } +} diff --git a/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/MethodRef.java b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/MethodRef.java new file mode 100644 index 0000000..0b2cf89 --- /dev/null +++ b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/MethodRef.java @@ -0,0 +1,16 @@ +package io.trygvis.container.compiler.model; + +public class MethodRef { + public final TypeRef returnType; + public final String name; + public final ParameterRef[] parameters; + public final String body; + + public + MethodRef(TypeRef returnType, String name, ParameterRef[] parameters, String body) { + this.returnType = returnType; + this.name = name; + this.parameters = parameters; + this.body = body; + } +} diff --git a/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ParameterRef.java b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ParameterRef.java new file mode 100644 index 0000000..fc69cb1 --- /dev/null +++ b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/ParameterRef.java @@ -0,0 +1,11 @@ +package io.trygvis.container.compiler.model; + +public class ParameterRef { + public final TypeRef klass; + public final String name; + + public ParameterRef(TypeRef klass, String name) { + this.klass = klass; + this.name = name; + } +} diff --git a/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/TypeRef.java b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/TypeRef.java new file mode 100644 index 0000000..aabfb45 --- /dev/null +++ b/container-compiler-plugin/src/main/java/io/trygvis/container/compiler/model/TypeRef.java @@ -0,0 +1,83 @@ +package io.trygvis.container.compiler.model; + +import javax.lang.model.type.TypeKind; + +public class TypeRef implements Comparable<TypeRef> { + + public static final TypeRef VOID = new TypeRef("void", "void"); + public static final TypeRef BOOLEAN = new TypeRef("boolean", null); + public static final TypeRef BYTE = new TypeRef("byte", null); + public static final TypeRef SHORT = new TypeRef("short", null); + public static final TypeRef CHAR = new TypeRef("char", null); + public static final TypeRef INT = new TypeRef("int", null); + public static final TypeRef LONG = new TypeRef("long", null); + public static final TypeRef FLOAT = new TypeRef("float", null); + public static final TypeRef DOUBLE = new TypeRef("double", null); + + /** + * The name of a class used within a class file. Is either the simple name or the canonical name. + */ + public final String name; + + private final String canonicalName; + + public String canonicalName() { + if (canonicalName == null) { + throw new RuntimeException("This type doesn't have a canonical name"); + } + + return canonicalName; + } + + public boolean isPrimitive() { + return canonicalName == null; + } + + public TypeRef(String name, String canonicalName) { + this.name = name; + this.canonicalName = canonicalName; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof TypeRef)) return false; + + TypeRef classRef = (TypeRef) o; + + return canonicalName.equals(classRef.canonicalName); + } + + @Override + public int hashCode() { + return canonicalName.hashCode(); + } + + @Override + public int compareTo(TypeRef o) { + return canonicalName.compareTo(o.canonicalName); + } + + public static TypeRef find(TypeKind kind) { + switch (kind) { + case BOOLEAN: + return BOOLEAN; + case BYTE: + return BYTE; + case SHORT: + return SHORT; + case CHAR: + return CHAR; + case INT: + return INT; + case LONG: + return LONG; + case FLOAT: + return FLOAT; + case DOUBLE: + return DOUBLE; + } + + throw new RuntimeException("Unknown kind: " + kind); + } +} |