private Type createType(TypeElement typeElement, TypeCategory category, List<? extends TypeMirror> typeArgs, boolean deep) { String name = typeElement.getQualifiedName().toString(); String simpleName = typeElement.getSimpleName().toString(); String packageName = env.getElementUtils().getPackageOf(typeElement).getQualifiedName().toString(); Type[] params = new Type[typeArgs.size()]; for (int i = 0; i < params.length; i++) { params[i] = getType(typeArgs.get(i), deep); } return new SimpleType(category, name, packageName, simpleName, false, typeElement.getModifiers().contains(Modifier.FINAL), params); }
@Override public Type asArrayType() { if (arrayType == null) { String newFullName = getFullName() + "[]"; String newSimpleName = getSimpleName() + "[]"; arrayType = new SimpleType(TypeCategory.ARRAY, newFullName, getPackageName(), newSimpleName, false, false); } return arrayType; }
@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 toString() { return getGenericName(true); }
@Override public Class<?> getJavaClass() { if (javaClass == null) { String className; if (packageName.length() > 0) { className = packageName + "." + localName.replace('.', '$'); } else { className = localName.replace('.', '$'); } try { if (className.endsWith("[]")) { Class<?> component = getComponentType().getJavaClass(); javaClass = Array.newInstance(component, 0).getClass(); } else if (PRIMITIVES.containsKey(className)) { javaClass = PRIMITIVES.get(className); } else { javaClass = Class.forName(className); } } catch (ClassNotFoundException e) { throw new RuntimeException(e); } } return javaClass; }
@Override public String getGenericName(boolean asArgType) { return getGenericName(asArgType, Collections.singleton("java.lang"), Collections.<String> emptySet()); }
private static void registerJTSTypes(TypeMappings typeMappings) { Map<String, String> additions = Maps.newHashMap(); additions.put("Geometry", "JTSGeometryPath"); additions.put("GeometryCollection", "JTSGeometryCollectionPath"); additions.put("LinearRing", "JTSLinearRingPath"); additions.put("LineString", "JTSLineStringPath"); additions.put("MultiLineString", "JTSMultiLineStringPath"); additions.put("MultiPoint", "JTSMultiPointPath"); additions.put("MultiPolygon", "JTSMultiPolygonPath"); additions.put("Point", "JTSPointPath"); additions.put("Polygon", "JTSPolygonPath"); for (Map.Entry<String, String> entry : additions.entrySet()) { typeMappings.register( new SimpleType("com.vividsolutions.jts.geom." + entry.getKey()), new SimpleType("com.querydsl.spatial.jts." + entry.getValue())); } }
private static void registerTypes(TypeMappings typeMappings) { Map<String, String> additions = Maps.newHashMap(); additions.put("Geometry", "GeometryPath"); additions.put("GeometryCollection", "GeometryCollectionPath"); additions.put("LinearRing", "LinearRingPath"); additions.put("LineString", "LineStringPath"); additions.put("MultiLineString", "MultiLineStringPath"); additions.put("MultiPoint", "MultiPointPath"); additions.put("MultiPolygon", "MultiPolygonPath"); additions.put("Point", "PointPath"); additions.put("Polygon", "PolygonPath"); additions.put("PolyHedralSurface", "PolyhedralSurfacePath"); for (Map.Entry<String, String> entry : additions.entrySet()) { typeMappings.register( new SimpleType("org.geolatte.geom." + entry.getKey()), new SimpleType("com.querydsl.spatial." + entry.getValue())); } }
private Type asGeneric(Type type) { if (type.getParameters().size() == 0) { int count = type.getJavaClass().getTypeParameters().length; if (count > 0) { return new SimpleType(type, new Type[count]); } } return type; }
private Type getRaw(Type type) { if (type instanceof EntityType && type.getPackageName().startsWith("ext.java")) { return type; } else { return new SimpleType(type, type.getParameters()); } }
public Type getQueryType(Type type, EntityType model, Type exprType, boolean raw, boolean rawParameters, boolean extend) { TypeCategory category = type.getCategory(); if (raw && category != TypeCategory.ENTITY && category != TypeCategory.CUSTOM) { return exprType; } else if (category == TypeCategory.STRING || category == TypeCategory.BOOLEAN) { return exprType; } else { if (rawParameters) { type = new SimpleType(type); } if (!type.isFinal() && extend) { type = new TypeExtends(type); } return new SimpleType(exprType, type); } }
private Type createCollectionType(Type baseType, Iterator<? extends TypeMirror> typeMirrors, boolean deep) { if (!typeMirrors.hasNext()) { return new SimpleType(baseType, defaultType); } Type componentType = getType(typeMirrors.next(), deep); if (componentType == null) { componentType = defaultType; } else if (componentType.getParameters().isEmpty()) { TypeElement element = env.getElementUtils().getTypeElement(componentType.getFullName()); if (element != null) { Type type = getType(element.asType(), deep); if (!type.getParameters().isEmpty()) { componentType = new SimpleType(componentType, new Type[type.getParameters().size()]); } } } return new SimpleType(baseType, componentType); }
private Type createWithPackage(Type type) { String packageName = type.getPackageName(); String simpleName = prefix + normalizeName(type.getFullName() .substring(packageName.length() + 1)) + suffix; packageName = (packageName.startsWith("java") ? "ext." : "") + packageName + packageSuffix; return new SimpleType(type.getCategory(), packageName + "." + simpleName, packageName, simpleName, false, false); }
private Type createMapType(Iterator<? extends TypeMirror> typeMirrors, boolean deep) { if (!typeMirrors.hasNext()) { return new SimpleType(Types.MAP, defaultType, defaultType); } Type keyType = getType(typeMirrors.next(), deep); if (keyType == null) { keyType = defaultType; } Type valueType = getType(typeMirrors.next(), deep); if (valueType == null) { valueType = defaultType; } else if (valueType.getParameters().isEmpty()) { TypeElement element = env.getElementUtils().getTypeElement(valueType.getFullName()); if (element != null) { Type type = getType(element.asType(), deep); if (!type.getParameters().isEmpty()) { valueType = new SimpleType(valueType, new Type[type.getParameters().size()]); } } } return new SimpleType(Types.MAP, keyType, valueType); }
private static Type resolveWithParameters(Type type, Type declaringType, EntityType context) { Type[] params = new Type[type.getParameters().size()]; boolean transformed = false; for (int i = 0; i < type.getParameters().size(); i++) { Type param = type.getParameters().get(i); if (param != null && !param.getFullName().equals(type.getFullName())) { params[i] = resolve(param, declaringType, context); if (!params[i].equals(param)) { transformed = true; } } } if (transformed) { return new SimpleType(type, params); } else { return type; } }
private Type createWithoutPackage(Type type) { String simpleName = prefix + normalizeName(type.getFullName()) + suffix; return new SimpleType(type.getCategory(), simpleName, "", simpleName, false, false); }
value = createOther(cl, entity, annotationHelper, annotation, parameters); } else if (Map.class.isAssignableFrom(cl)) { value = new SimpleType(Types.MAP, parameters[0], asGeneric(parameters[1])); } else if (List.class.isAssignableFrom(cl)) { value = new SimpleType(Types.LIST, asGeneric(parameters[0])); } else if (Set.class.isAssignableFrom(cl)) { value = new SimpleType(Types.SET, asGeneric(parameters[0])); } else if (Collection.class.isAssignableFrom(cl)) { value = new SimpleType(Types.COLLECTION, asGeneric(parameters[0])); } else { value = createOther(cl, entity, annotationHelper, annotation, parameters);
@Before public void setUp() { typeModel = new SimpleType(TypeCategory.ENTITY, "com.querydsl.DomainClass", "com.querydsl", "DomainClass", false,false); type = new EntityType(typeModel); }
@Before public void setUp() { typeModel = new SimpleType(TypeCategory.ENTITY, "com.querydsl.DomainClass", "com.querydsl", "DomainClass", false,false); type = new EntityType(typeModel); }
@Test public void original_category() throws IOException { Map<TypeCategory, String> categoryToSuperClass = new EnumMap<TypeCategory, String>(TypeCategory.class); categoryToSuperClass.put(TypeCategory.COMPARABLE, "ComparablePath<Entity>"); categoryToSuperClass.put(TypeCategory.ENUM, "EnumPath<Entity>"); categoryToSuperClass.put(TypeCategory.DATE, "DatePath<Entity>"); categoryToSuperClass.put(TypeCategory.DATETIME, "DateTimePath<Entity>"); categoryToSuperClass.put(TypeCategory.TIME, "TimePath<Entity>"); categoryToSuperClass.put(TypeCategory.NUMERIC, "NumberPath<Entity>"); categoryToSuperClass.put(TypeCategory.STRING, "StringPath"); categoryToSuperClass.put(TypeCategory.BOOLEAN, "BooleanPath"); for (Map.Entry<TypeCategory, String> entry : categoryToSuperClass.entrySet()) { SimpleType type = new SimpleType(entry.getKey(), "Entity", "", "Entity",false,false); EntityType entityType = new EntityType(type); typeMappings.register(entityType, queryTypeFactory.create(entityType)); serializer.serialize(entityType, SimpleSerializerConfig.DEFAULT, new JavaWriter(writer)); assertTrue(entry.toString(), writer.toString().contains("public class QEntity extends " + entry.getValue() + " {")); } }