CodeCow/querydsl
1
0
Fork 0
mirror of https://github.com/querydsl/querydsl.git synced 2026-07-03 21:07:49 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Browse Source
This commit is contained in:
Timo Westkämper 2010-08-19 08:46:43 +00:00
parent 03295204c2
commit ded05cdedc
13 changed files with 206 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/java/com/mysema/codegen/AbstractCodeWriter.java
View File

@ -6,7 +6,6 @@
package com.mysema.codegen;
import static com.mysema.codegen.Symbols.NEWLINE;
import static com.mysema.codegen.Symbols.SEMICOLON;
import java.io.IOException;

13
src/main/java/com/mysema/codegen/CodeWriter.java
View File

@ -13,6 +13,7 @@ import javax.annotation.Nullable;
import org.apache.commons.collections15.Transformer;
import com.mysema.codegen.model.Parameter;
import com.mysema.codegen.model.Type;
/**
@ -31,21 +32,21 @@ public interface CodeWriter extends Appendable{
CodeWriter beginClass(Type type, @Nullable Type superClass, Type... interfaces) throws IOException;
<T> CodeWriter beginConstructor(Collection<T> params, Transformer<T, String> transformer) throws IOException;
<T> CodeWriter beginConstructor(Collection<T> params, Transformer<T, Parameter> transformer) throws IOException;
CodeWriter beginConstructor(String... params) throws IOException;
CodeWriter beginConstructor(Parameter... params) throws IOException;
CodeWriter beginInterface(Type type, Type... interfaces) throws IOException;
CodeWriter beginLine(String... segments) throws IOException;
<T> CodeWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, String> transformer) throws IOException;
<T> CodeWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, Parameter> transformer) throws IOException;
CodeWriter beginPublicMethod(Type returnType, String methodName, String... args) throws IOException;
CodeWriter beginPublicMethod(Type returnType, String methodName, Parameter... args) throws IOException;
<T> CodeWriter beginStaticMethod(Type type, String name, Collection<T> params, Transformer<T, String> transformer) throws IOException;
<T> CodeWriter beginStaticMethod(Type type, String name, Collection<T> params, Transformer<T, Parameter> transformer) throws IOException;
CodeWriter beginStaticMethod(Type returnType, String methodName, String... args) throws IOException;
CodeWriter beginStaticMethod(Type returnType, String methodName, Parameter... args) throws IOException;
CodeWriter end() throws IOException;

13
src/main/java/com/mysema/codegen/EvaluatorFactory.java
View File

@ -24,6 +24,7 @@ import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
import com.mysema.codegen.model.ClassType;
import com.mysema.codegen.model.Parameter;
import com.mysema.codegen.model.SimpleType;
import com.mysema.codegen.model.Type;
import com.mysema.codegen.model.TypeCategory;
@ -59,8 +60,7 @@ public class EvaluatorFactory {
this.loader = fileManager.getClassLoader(StandardLocation.CLASS_OUTPUT);
this.compilationOptions = Arrays.asList("-classpath", classpath, "-g:none");
}
@SuppressWarnings("unchecked")
private void compile(String source, Type projectionType,
String[] names, Type[] types, String id, Map<String,Object> constants) throws IOException {
// create source
@ -68,9 +68,9 @@ public class EvaluatorFactory {
JavaWriter javaw = new JavaWriter(writer);
SimpleType idType = new SimpleType(id, "", id);
javaw.beginClass(idType, null);
String[] params = new String[names.length];
Parameter[] params = new Parameter[names.length];
for (int i = 0; i < params.length; i++) {
params[i] = types[i].getGenericName(true) + " " + names[i];
params[i] = new Parameter(names[i], types[i]);
}
for (Map.Entry<String,Object> entry : constants.entrySet()){
@ -105,7 +105,6 @@ public class EvaluatorFactory {
}
@SuppressWarnings("unchecked")
public <T> Evaluator<T> createEvaluator(
String source,
Class<? extends T> projectionType,
@ -132,7 +131,7 @@ public class EvaluatorFactory {
*/
public <T> Evaluator<T> createEvaluator(
String source,
ClassType<? extends T> projection,
ClassType projection,
String[] names,
Type[] types,
Class<?>[] classes,
@ -156,7 +155,7 @@ public class EvaluatorFactory {
}
Method method = clazz.getMethod("eval", classes);
return new MethodEvaluator<T>(method, object, projection.getJavaClass());
return new MethodEvaluator<T>(method, object, (Class)projection.getJavaClass());
} catch (ClassNotFoundException e) {
throw new CodegenException(e);
} catch (SecurityException e) {

78
src/main/java/com/mysema/codegen/JavaWriter.java
View File

@ -22,8 +22,8 @@ import java.util.Set;
import org.apache.commons.collections15.Transformer;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import com.mysema.codegen.model.Parameter;
import com.mysema.codegen.model.Type;
@ -67,15 +67,15 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
private static final String PUBLIC_STATIC_FINAL = "public static final ";
private final Set<String> importedClasses = new HashSet<String>();
private final Set<String> classes = new HashSet<String>();
private final Set<String> importedPackages = new HashSet<String>();
private final Set<String> packages = new HashSet<String>();
private Type type;
public JavaWriter(Appendable appendable){
super(appendable);
this.importedPackages.add("java.lang");
this.packages.add("java.lang");
}
@Override
@ -148,7 +148,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
}
private JavaWriter appendType(Class<?> type) throws IOException{
if (importedClasses.contains(type.getName()) || importedPackages.contains(type.getPackage().getName())){
if (classes.contains(type.getName()) || packages.contains(type.getPackage().getName())){
append(type.getSimpleName());
}else{
append(type.getName());
@ -163,10 +163,10 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
@Override
public JavaWriter beginClass(Type type, Type superClass, Type... interfaces) throws IOException{
importedPackages.add(type.getPackageName());
packages.add(type.getPackageName());
beginLine(PUBLIC_CLASS + type.getSimpleName());
if (superClass != null){
append(EXTENDS + superClass.getGenericName(false, importedPackages, importedClasses));
append(EXTENDS + superClass.getGenericName(false, packages, classes));
}
if (interfaces.length > 0){
append(IMPLEMENTS);
@ -174,7 +174,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
if (i > 0){
append(COMMA);
}
append(interfaces[i].getGenericName(false, importedPackages, importedClasses));
append(interfaces[i].getGenericName(false, packages, classes));
}
}
append(" {").nl().nl();
@ -184,28 +184,28 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
}
@Override
public <T> JavaWriter beginConstructor(Collection<T> parameters, Transformer<T,String> transformer) throws IOException {
public <T> JavaWriter beginConstructor(Collection<T> parameters, Transformer<T,Parameter> transformer) throws IOException {
beginLine(PUBLIC + type.getSimpleName()).params(parameters, transformer).append(" {").nl();
return goIn();
}
@Override
public JavaWriter beginConstructor(String... parameters) throws IOException{
public JavaWriter beginConstructor(Parameter... parameters) throws IOException{
beginLine(PUBLIC + type.getSimpleName()).params(parameters).append(" {").nl();
return goIn();
}
@Override
public JavaWriter beginInterface(Type type, Type... interfaces) throws IOException {
importedPackages.add(type.getPackageName());
beginLine(PUBLIC_INTERFACE + type.getGenericName(false, importedPackages, importedClasses));
packages.add(type.getPackageName());
beginLine(PUBLIC_INTERFACE + type.getGenericName(false, packages, classes));
if (interfaces.length > 0){
append(EXTENDS);
for (int i = 0; i < interfaces.length; i++){
if (i > 0){
append(COMMA);
}
append(interfaces[i].getGenericName(false, importedPackages, importedClasses));
append(interfaces[i].getGenericName(false, packages, classes));
}
}
append(" {").nl().nl();
@ -214,28 +214,28 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
return this;
}
private JavaWriter beginMethod(String modifiers, Type returnType, String methodName, String... args) throws IOException{
beginLine(modifiers + returnType + SPACE + methodName).params(args).append(" {").nl();
private JavaWriter beginMethod(String modifiers, Type returnType, String methodName, Parameter... args) throws IOException{
beginLine(modifiers + returnType.getGenericName(true, packages, classes) + SPACE + methodName).params(args).append(" {").nl();
return goIn();
}
@Override
public <T> JavaWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, String> transformer) throws IOException {
public <T> JavaWriter beginPublicMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, Parameter> transformer) throws IOException {
return beginMethod(PUBLIC, returnType, methodName, transform(parameters, transformer));
}
@Override
public JavaWriter beginPublicMethod(Type returnType, String methodName, String... args) throws IOException{
public JavaWriter beginPublicMethod(Type returnType, String methodName, Parameter... args) throws IOException{
return beginMethod(PUBLIC, returnType, methodName, args);
}
@Override
public <T> JavaWriter beginStaticMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, String> transformer) throws IOException {
public <T> JavaWriter beginStaticMethod(Type returnType, String methodName, Collection<T> parameters, Transformer<T, Parameter> transformer) throws IOException {
return beginMethod(PUBLIC_STATIC, returnType, methodName, transform(parameters, transformer));
}
@Override
public JavaWriter beginStaticMethod(Type returnType, String methodName, String... args) throws IOException{
public JavaWriter beginStaticMethod(Type returnType, String methodName, Parameter... args) throws IOException{
return beginMethod(PUBLIC_STATIC, returnType, methodName, args);
}
@ -247,21 +247,21 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
@Override
public JavaWriter field(Type type, String name) throws IOException {
return line(type.getGenericName(false, importedPackages, importedClasses) + SPACE + name + SEMICOLON).nl();
return line(type.getGenericName(true, packages, classes) + SPACE + name + SEMICOLON).nl();
}
private JavaWriter field(String modifier, Type type, String name) throws IOException{
return line(modifier + type.getGenericName(false, importedPackages, importedClasses) + SPACE + name + SEMICOLON).nl();
return line(modifier + type.getGenericName(true, packages, classes) + SPACE + name + SEMICOLON).nl();
}
private JavaWriter field(String modifier, Type type, String name, String value) throws IOException{
return line(modifier + type.getGenericName(false, importedPackages, importedClasses) + SPACE + name + ASSIGN + value + SEMICOLON).nl();
return line(modifier + type.getGenericName(true, packages, classes) + SPACE + name + ASSIGN + value + SEMICOLON).nl();
}
@Override
public JavaWriter imports(Class<?>... imports) throws IOException{
for (Class<?> cl : imports){
importedClasses.add(cl.getName());
classes.add(cl.getName());
line(IMPORT + cl.getName() + SEMICOLON);
}
nl();
@ -271,7 +271,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
@Override
public JavaWriter imports(Package... imports) throws IOException {
for (Package p : imports){
importedPackages.add(p.getName());
packages.add(p.getName());
line(IMPORT + p.getName() + ".*;");
}
nl();
@ -281,7 +281,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
@Override
public JavaWriter importClasses(String... imports) throws IOException{
for (String cl : imports){
importedClasses.add(cl);
classes.add(cl);
line(IMPORT + cl + SEMICOLON);
}
nl();
@ -291,7 +291,7 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
@Override
public JavaWriter importPackages(String... imports) throws IOException {
for (String p : imports){
importedPackages.add(p);
packages.add(p);
line(IMPORT + p + ".*;");
}
nl();
@ -309,31 +309,43 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
@Override
public JavaWriter packageDecl(String packageName) throws IOException{
importedPackages.add(packageName);
packages.add(packageName);
return line(PACKAGE + packageName + SEMICOLON).nl();
}
private <T> JavaWriter params(Collection<T> parameters, Transformer<T,String> transformer) throws IOException{
private <T> JavaWriter params(Collection<T> parameters, Transformer<T,Parameter> transformer) throws IOException{
append("(");
boolean first = true;
for (T param : parameters){
if (!first){
append(COMMA);
}
append(transformer.transform(param));
param(transformer.transform(param));
first = false;
}
append(")");
return this;
}
private JavaWriter params(String... params) throws IOException{
private JavaWriter params(Parameter... params) throws IOException{
append("(");
append(StringUtils.join(params, COMMA));
for (int i = 0; i < params.length; i++){
if (i > 0){
append(COMMA);
}
param(params[i]);
}
append(")");
return this;
}
private JavaWriter param(Parameter parameter) throws IOException{
append(parameter.getType().getGenericName(true, packages, classes));
append(" ");
append(parameter.getName());
return this;
}
@Override
public JavaWriter privateField(Type type, String name) throws IOException {
return field(PRIVATE, type, name);
@ -402,8 +414,8 @@ public final class JavaWriter extends AbstractCodeWriter<JavaWriter>{
return line("@SuppressWarnings(\"" + type +"\")");
}
private <T> String[] transform(Collection<T> parameters, Transformer<T,String> transformer){
String[] rv = new String[parameters.size()];
private <T> Parameter[] transform(Collection<T> parameters, Transformer<T,Parameter> transformer){
Parameter[] rv = new Parameter[parameters.size()];
int i = 0;
for (T value : parameters){
rv[i++] = transformer.transform(value);

70
src/main/java/com/mysema/codegen/model/ClassType.java
View File

@ -23,57 +23,60 @@ import com.mysema.codegen.support.ClassUtils;
* @param <T>
*/
@Immutable
public class ClassType<T> implements Type {
public class ClassType implements Type {
private final TypeCategory category;
private final Class<T> javaClass;
private final Class<?> javaClass;
private final List<Type> parameters;
@Nullable
private final Class<?> primitiveClass;
private Type arrayType, componentType;
public ClassType(Class<T> javaClass) {
this(TypeCategory.SIMPLE, javaClass, null, Collections.<Type>emptyList());
public ClassType(Class<?> javaClass, Type... parameters) {
this(TypeCategory.SIMPLE, javaClass, null, Arrays.asList(parameters));
}
public ClassType(TypeCategory category, Class<T> javaClass, List<Type> parameters) {
this(category, javaClass, null, parameters);
public ClassType(TypeCategory category, Class<?> javaClass, Class<?> primitiveClass) {
this(category, javaClass, primitiveClass, Collections.<Type>emptyList());
}
public ClassType(TypeCategory category, Class<T> clazz, Type... parameters) {
this(category, clazz, null, Arrays.asList(parameters));
}
public ClassType(TypeCategory category, Class<T> javaClass, Class<?> primitiveClass) {
this(category, javaClass, primitiveClass, Collections.<Type>emptyList());
}
public ClassType(TypeCategory category, Class<T> javaClass, @Nullable Class<?> primitiveClass, List<Type> parameters) {
public ClassType(TypeCategory category, Class<?> javaClass, @Nullable Class<?> primitiveClass, List<Type> parameters) {
this.category = category;
this.javaClass = javaClass;
this.primitiveClass = primitiveClass;
this.parameters = parameters;
}
public ClassType(TypeCategory category, Class<?> javaClass, List<Type> parameters) {
this(category, javaClass, null, parameters);
}
public ClassType(TypeCategory category, Class<?> clazz, Type... parameters) {
this(category, clazz, null, Arrays.asList(parameters));
}
@Override
public Type as(TypeCategory c) {
if (category == c){
return this;
}else{
return new ClassType<T>(c, javaClass);
return new ClassType(c, javaClass);
}
}
@Override
public Type asArrayType() {
String fullName = javaClass.getName()+"[]";
String simpleName = javaClass.getSimpleName()+"[]";
return new SimpleType(TypeCategory.ARRAY, fullName, getPackageName(), simpleName, false, false);
if (arrayType == null){
String fullName = javaClass.getName()+"[]";
String simpleName = javaClass.getSimpleName()+"[]";
arrayType = new SimpleType(TypeCategory.ARRAY, fullName, getPackageName(), simpleName, false, false);
}
return arrayType;
}
@Override
public boolean equals(Object o){
@ -86,11 +89,20 @@ public class ClassType<T> implements Type {
return false;
}
}
public TypeCategory getCategory() {
return category;
}
@Override
public Type getComponentType() {
Class<?> clazz = javaClass.getComponentType();
if (clazz != null && componentType == null){
componentType = new ClassType(TypeCategory.SIMPLE, clazz);
}
return componentType;
}
@Override
public String getFullName() {
return javaClass.getName();
@ -112,7 +124,7 @@ public class ClassType<T> implements Type {
boolean first = true;
for (Type parameter : parameters){
if (!first){
builder.append(",");
builder.append(", ");
}
if (parameter == null || parameter.getFullName().equals(getFullName())){
builder.append("?");
@ -126,13 +138,17 @@ public class ClassType<T> implements Type {
}
}
public Class<T> getJavaClass() {
public Class<?> getJavaClass() {
return javaClass;
}
@Override
public String getPackageName() {
return javaClass.getPackage().getName();
if (javaClass.getPackage() != null){
return javaClass.getPackage().getName();
}else{
return "";
}
}
@Override
@ -154,17 +170,17 @@ public class ClassType<T> implements Type {
public String getSimpleName() {
return javaClass.getSimpleName();
}
@Override
public int hashCode(){
return javaClass.getName().hashCode();
}
@Override
public boolean isFinal() {
return Modifier.isFinal(javaClass.getModifiers());
}
@Override
public boolean isPrimitive() {
// return javaClass.isPrimitive();

56
src/main/java/com/mysema/codegen/model/SimpleType.java
View File

@ -26,19 +26,21 @@ public class SimpleType implements Type {
private final List<Type> parameters;
private final boolean primitiveClass, finalClass;
public SimpleType(Type type, Type... parameters) {
this(type.getCategory(), type.getFullName(), type.getPackageName(), type.getSimpleName(),
type.isPrimitive(), type.isFinal(), Arrays.asList(parameters));
}
private Type arrayType, componentType;
public SimpleType(String fullName, String packageName, String simpleName, Type... parameters) {
this(TypeCategory.SIMPLE, fullName, packageName, simpleName, false, false, Arrays.asList(parameters));
}
public SimpleType(TypeCategory typeCategory, String fullName, String packageName, String simpleName, boolean p, boolean f, Type... parameters) {
this(typeCategory, fullName, packageName, simpleName, p, f, Arrays
.asList(parameters));
public SimpleType(Type type, List<Type> parameters) {
this(type.getCategory(), type.getFullName(), type.getPackageName(), type.getSimpleName(),
type.isPrimitive(), type.isFinal(), parameters);
}
public SimpleType(Type type, Type... parameters) {
this(type.getCategory(), type.getFullName(), type.getPackageName(), type.getSimpleName(),
type.isPrimitive(), type.isFinal(), Arrays.asList(parameters));
}
public SimpleType(TypeCategory category, String fullName, String packageName, String simpleName,
@ -56,6 +58,11 @@ public class SimpleType implements Type {
this.finalClass = finalClass;
this.parameters = parameters;
}
public SimpleType(TypeCategory typeCategory, String fullName, String packageName, String simpleName, boolean p, boolean f, Type... parameters) {
this(typeCategory, fullName, packageName, simpleName, p, f, Arrays
.asList(parameters));
}
@Override
public Type as(TypeCategory c) {
@ -68,11 +75,13 @@ public class SimpleType implements Type {
@Override
public Type asArrayType() {
String newFullName = getFullName()+"[]";
String newSimpleName = getSimpleName()+"[]";
return new SimpleType(TypeCategory.ARRAY, newFullName, getPackageName(), newSimpleName, false, false);
if (arrayType == null){
String newFullName = getFullName()+"[]";
String newSimpleName = getSimpleName()+"[]";
arrayType = new SimpleType(TypeCategory.ARRAY, newFullName, getPackageName(), newSimpleName, false, false);
}
return arrayType;
}
@Override
public boolean equals(Object o){
@ -85,11 +94,25 @@ public class SimpleType implements Type {
return false;
}
}
public TypeCategory getCategory() {
return category;
}
@Override
public Type getComponentType() {
if (fullName.endsWith("[]")){
if (componentType == null){
String newFullName = fullName.substring(0, fullName.length()-2);
String newSimpleName = simpleName.substring(0, simpleName.length()-2);
componentType = new SimpleType(TypeCategory.SIMPLE, newFullName, getPackageName(), newSimpleName, false, false);
}
return componentType;
}else{
return null;
}
}
@Override
public String getFullName() {
return fullName;
@ -111,7 +134,7 @@ public class SimpleType implements Type {
boolean first = true;
for (Type parameter : parameters){
if (!first){
builder.append(",");
builder.append(", ");
}
if (parameter == null || parameter.getFullName().equals(fullName)){
builder.append("?");
@ -153,7 +176,7 @@ public class SimpleType implements Type {
public String getSimpleName() {
return simpleName;
}
@Override
public int hashCode(){
return fullName.hashCode();
@ -168,9 +191,10 @@ public class SimpleType implements Type {
public boolean isPrimitive() {
return primitiveClass;
}
public String toString(){
return getGenericName(true);
}
}

3
src/main/java/com/mysema/codegen/model/Type.java
View File

@ -19,6 +19,9 @@ public interface Type {
Type asArrayType();
@Nullable
Type getComponentType();
TypeCategory getCategory();
String getFullName();

5
src/main/java/com/mysema/codegen/model/TypeAdapter.java
View File

@ -35,6 +35,11 @@ public class TypeAdapter implements Type{
return type.asArrayType();
}
@Override
public Type getComponentType() {
return type.getComponentType();
}
@Override
public boolean equals(Object o){
return type.equals(o);

59
src/main/java/com/mysema/codegen/model/Types.java
View File

@ -18,50 +18,63 @@ import java.util.Set;
* @author tiwe
*
*/
@SuppressWarnings("unchecked")
public final class Types {
public static final ClassType<Object> OBJECT = new ClassType<Object>(TypeCategory.SIMPLE,Object.class);
public static final ClassType OBJECT = new ClassType(TypeCategory.SIMPLE, Object.class);
public static final ClassType<Object[]> OBJECTS = new ClassType<Object[]>(TypeCategory.ARRAY,Object[].class);
public static final ClassType OBJECTS = new ClassType(TypeCategory.ARRAY, Object[].class);
public static final ClassType<BigDecimal> BIG_DECIMAL = new ClassType<BigDecimal>(TypeCategory.NUMERIC,BigDecimal.class);
public static final ClassType BIG_DECIMAL = new ClassType(TypeCategory.NUMERIC, BigDecimal.class);
public static final ClassType<BigInteger> BIG_INTEGER = new ClassType<BigInteger>(TypeCategory.NUMERIC,BigInteger.class);
public static final ClassType BIG_INTEGER = new ClassType(TypeCategory.NUMERIC, BigInteger.class);
public static final ClassType<Boolean> BOOLEAN = new ClassType<Boolean>(TypeCategory.BOOLEAN,Boolean.class, boolean.class);
public static final ClassType BOOLEAN = new ClassType(TypeCategory.BOOLEAN, Boolean.class, boolean.class);
public static final ClassType<Byte> BYTE = new ClassType<Byte>(TypeCategory.NUMERIC,Byte.class, byte.class);
public static final ClassType BOOLEAN_P = new ClassType(TypeCategory.BOOLEAN, boolean.class);
public static final ClassType<Character> CHAR = new ClassType<Character>(TypeCategory.COMPARABLE,Character.class, char.class);
public static final ClassType<Collection> COLLECTION = new ClassType<Collection>(TypeCategory.COLLECTION, Collection.class, OBJECT);
public static final ClassType BYTE = new ClassType(TypeCategory.NUMERIC, Byte.class, byte.class);
public static final ClassType<Double> DOUBLE = new ClassType<Double>(TypeCategory.NUMERIC,Double.class, double.class);
public static final ClassType BYTE_P = new ClassType(TypeCategory.NUMERIC, byte.class);
public static final ClassType CHARACTER = new ClassType(TypeCategory.COMPARABLE, Character.class, char.class);
public static final ClassType CHAR = new ClassType(TypeCategory.COMPARABLE, char.class);
public static final ClassType<Float> FLOAT = new ClassType<Float>(TypeCategory.NUMERIC,Float.class, float.class);
public static final ClassType COLLECTION = new ClassType(TypeCategory.COLLECTION, Collection.class, OBJECT);
public static final ClassType DOUBLE = new ClassType(TypeCategory.NUMERIC, Double.class, double.class);
public static final ClassType DOUBLE_P = new ClassType(TypeCategory.NUMERIC, double.class);
public static final ClassType<Integer> INT = new ClassType<Integer>(TypeCategory.NUMERIC,Integer.class, int.class);
public static final ClassType FLOAT = new ClassType(TypeCategory.NUMERIC, Float.class, float.class);
public static final ClassType<Iterable> ITERABLE = new ClassType<Iterable>(TypeCategory.SIMPLE, Iterable.class, OBJECT);
public static final ClassType INTEGER = new ClassType(TypeCategory.NUMERIC, Integer.class);
public static final ClassType INT = new ClassType(TypeCategory.NUMERIC, int.class);
public static final ClassType<List> LIST = new ClassType<List>(TypeCategory.LIST, List.class, OBJECT);
public static final ClassType ITERABLE = new ClassType(TypeCategory.SIMPLE, Iterable.class, OBJECT);
public static final ClassType<Locale> LOCALE = new ClassType<Locale>(TypeCategory.SIMPLE, Locale.class);
public static final ClassType LIST = new ClassType(TypeCategory.LIST, List.class, OBJECT);
public static final ClassType<Long> LONG = new ClassType<Long>(TypeCategory.NUMERIC,Long.class, long.class);
public static final ClassType LOCALE = new ClassType(TypeCategory.SIMPLE, Locale.class);
public static final ClassType LONG = new ClassType(TypeCategory.NUMERIC, Long.class, long.class);
public static final ClassType LONG_P = new ClassType(TypeCategory.NUMERIC, long.class);
public static final ClassType<Map> MAP = new ClassType<Map>(TypeCategory.MAP, Map.class, OBJECT, OBJECT);
public static final ClassType MAP = new ClassType(TypeCategory.MAP, Map.class, OBJECT, OBJECT);
public static final ClassType<Set> SET = new ClassType<Set>(TypeCategory.SET, Set.class, OBJECT);
public static final ClassType SET = new ClassType(TypeCategory.SET, Set.class, OBJECT);
public static final ClassType<Short> SHORT = new ClassType<Short>(TypeCategory.NUMERIC,Short.class, short.class);
public static final ClassType SHORT = new ClassType(TypeCategory.NUMERIC, Short.class, short.class);
public static final ClassType<String> STRING = new ClassType<String>(TypeCategory.STRING,String.class);
public static final ClassType SHORT_P = new ClassType(TypeCategory.NUMERIC, short.class);
public static final ClassType<URI> URI = new ClassType<URI>(TypeCategory.COMPARABLE,URI.class);
public static final ClassType STRING = new ClassType(TypeCategory.STRING, String.class);
public static final ClassType<Void> VOID = new ClassType<Void>(TypeCategory.SIMPLE, void.class);
public static final ClassType URI = new ClassType(TypeCategory.COMPARABLE, URI.class);
public static final ClassType VOID = new ClassType(TypeCategory.SIMPLE, void.class);
public static final SimpleType DATE_TIME = new SimpleType(TypeCategory.DATETIME, "org.joda.time.DateTime", "org.joda.time", "DateTime", false, false);

5
src/test/java/com/mysema/codegen/ComplexEvaluationTest.java
View File

@ -17,6 +17,7 @@ import org.junit.Test;
import com.mysema.codegen.model.ClassType;
import com.mysema.codegen.model.Type;
import com.mysema.codegen.model.TypeCategory;
import com.mysema.codegen.model.Types;
public class ComplexEvaluationTest {
@ -25,8 +26,8 @@ public class ComplexEvaluationTest {
@Test
@SuppressWarnings("unchecked")
public void testComplex(){ClassType<String> stringType = new ClassType<String>(TypeCategory.STRING,String.class);
ClassType<List> resultType = new ClassType<List>(TypeCategory.LIST,List.class, stringType);
public void testComplex(){
ClassType resultType = new ClassType(TypeCategory.LIST,List.class, Types.STRING);
StringBuilder source = new StringBuilder();
source.append("java.util.List<String> rv = new java.util.ArrayList<String>();\n");
source.append("for (String a : a_){\n");

21
src/test/java/com/mysema/codegen/JavaWriterTest.java
View File

@ -18,16 +18,17 @@ import org.junit.Before;
import org.junit.Test;
import com.mysema.codegen.model.ClassType;
import com.mysema.codegen.model.Parameter;
import com.mysema.codegen.model.SimpleType;
import com.mysema.codegen.model.Type;
import com.mysema.codegen.model.Types;
public class JavaWriterTest {
private static final Transformer<String,String> transformer = new Transformer<String,String>(){
@Override
public String transform(String input) {
return input;
private static final Transformer<Parameter,Parameter> transformer = new Transformer<Parameter,Parameter>(){
@Override
public Parameter transform(Parameter input) {
return input;
}
};
@ -48,7 +49,7 @@ public class JavaWriterTest {
public void setUp(){
w = new StringWriter();
writer = new JavaWriter(w);
testType = new ClassType<JavaWriterTest>(JavaWriterTest.class);
testType = new ClassType(JavaWriterTest.class);
testType2 = new SimpleType("com.mysema.codegen.Test","com.mysema.codegen","Test");
testSuperType = new SimpleType("com.mysema.codegen.Superclass","com.mysema.codegen","Superclass");
testInterface1 = new SimpleType("com.mysema.codegen.TestInterface1","com.mysema.codegen","TestInterface1");
@ -189,11 +190,11 @@ public class JavaWriterTest {
// method
// public
writer.beginPublicMethod(Types.STRING, "publicMethod", Arrays.asList("String a"), transformer);
writer.beginPublicMethod(Types.STRING, "publicMethod", Arrays.asList(new Parameter("a", Types.STRING)), transformer);
writer.line("return null;");
writer.end();
writer.beginStaticMethod(Types.STRING, "staticMethod", Arrays.asList("String a"), transformer);
writer.beginStaticMethod(Types.STRING, "staticMethod", Arrays.asList(new Parameter("a", Types.STRING)), transformer);
writer.line("return null;");
writer.end();
@ -206,10 +207,10 @@ public class JavaWriterTest {
public void testConstructors() throws IOException{
writer.beginClass(testType);
writer.beginConstructor(Arrays.asList("String a","String b"), transformer);
writer.beginConstructor(Arrays.asList(new Parameter("a", Types.STRING), new Parameter("b", Types.STRING)), transformer);
writer.end();
writer.beginConstructor("String a");
writer.beginConstructor(new Parameter("a", Types.STRING));
writer.end();
writer.end();

5
src/test/java/com/mysema/codegen/model/ClassTypeTest.java
View File

@ -15,7 +15,7 @@ import org.junit.Test;
public class ClassTypeTest {
private ClassType<String> stringType = new ClassType<String>(TypeCategory.STRING, String.class);
private ClassType stringType = new ClassType(TypeCategory.STRING, String.class);
// @Test
// public void asArrayType(){
@ -27,10 +27,9 @@ public class ClassTypeTest {
assertEquals(TypeCategory.COMPARABLE, stringType.as(TypeCategory.COMPARABLE).getCategory());
}
@SuppressWarnings("unchecked")
@Test
public void getParameters(){
ClassType<Map> mapType = new ClassType<Map>(TypeCategory.MAP, Map.class, stringType, stringType);
ClassType mapType = new ClassType(TypeCategory.MAP, Map.class, stringType, stringType);
assertEquals(2, mapType.getParameters().size());
assertEquals(stringType, mapType.getParameters().get(0));
assertEquals(stringType, mapType.getParameters().get(1));

10
src/test/java/com/mysema/codegen/model/TypeTest.java
View File

@ -22,7 +22,7 @@ public class TypeTest {
private Set<String> emptyStrings = Collections.<String>emptySet();
private ClassType<Locale> locale = new ClassType<Locale>(TypeCategory.SIMPLE,Locale.class);
private ClassType locale = new ClassType(TypeCategory.SIMPLE,Locale.class);
private Type string = Types.STRING;
@ -30,11 +30,11 @@ public class TypeTest {
private Type locale2 = new SimpleType(locale);
private Type stringList = new ClassType<List>(TypeCategory.LIST, List.class, Types.STRING);
private Type stringList = new ClassType(TypeCategory.LIST, List.class, Types.STRING);
private Type stringList2 = new SimpleType(Types.LIST, Types.STRING);
private Type stringMap = new ClassType<Map>(TypeCategory.MAP, Map.class, Types.STRING, Types.STRING);
private Type stringMap = new ClassType(TypeCategory.MAP, Map.class, Types.STRING, Types.STRING);
private Type stringMap2 = new SimpleType(Types.MAP, Types.STRING, Types.STRING);
@ -63,8 +63,8 @@ public class TypeTest {
assertEquals("java.util.Locale",locale2.getGenericName(true));
assertEquals("java.util.List<String>",stringList.getGenericName(true));
assertEquals("java.util.List<String>",stringList2.getGenericName(true));
assertEquals("java.util.Map<String,String>", stringMap.getGenericName(true));
assertEquals("java.util.Map<String,String>", stringMap2.getGenericName(true));
assertEquals("java.util.Map<String, String>", stringMap.getGenericName(true));
assertEquals("java.util.Map<String, String>", stringMap2.getGenericName(true));
assertEquals("String", string.getGenericName(true));
assertEquals("String", string2.getGenericName(true));