private Type createInterfaceType(DeclaredType declaredType, TypeElement typeElement, boolean deep) { // entity type for (Class<? extends Annotation> entityAnn : entityAnnotations) { if (typeElement.getAnnotation(entityAnn) != null) { return createType(typeElement, TypeCategory.ENTITY, declaredType.getTypeArguments(), deep); } } Iterator<? extends TypeMirror> i = declaredType.getTypeArguments().iterator(); if (isAssignable(declaredType, mapType)) { return createMapType(i, deep); } else if (isAssignable(declaredType, listType)) { return createCollectionType(Types.LIST, i, deep); } else if (isAssignable(declaredType, setType)) { return createCollectionType(Types.SET, i, deep); } else if (isAssignable(declaredType, collectionType)) { return createCollectionType(Types.COLLECTION, i, deep); } else { String name = typeElement.getQualifiedName().toString(); return createType(typeElement, TypeCategory.get(name), declaredType.getTypeArguments(), deep); } }
@Nullable private Property createProperty(EntityType entityType, String propertyName, Type propertyType, AnnotatedElement annotated) { List<String> inits = Collections.emptyList(); if (annotated.isAnnotationPresent(skipAnnotation) && !annotated.isAnnotationPresent(QueryType.class)) { return null; } if (annotated.isAnnotationPresent(QueryInit.class)) { inits = ImmutableList.copyOf(annotated.getAnnotation(QueryInit.class).value()); } if (annotated.isAnnotationPresent(QueryType.class)) { QueryType queryType = annotated.getAnnotation(QueryType.class); if (queryType.value().equals(PropertyType.NONE)) { return null; } propertyType = propertyType.as(TypeCategory.valueOf(queryType.value().name())); } return new Property(entityType, propertyName, propertyType, inits); }
private Type createOther(Class<?> cl, boolean entity, AnnotationHelper annotationHelper, Annotation annotation, Type[] parameters) { TypeCategory typeCategory = TypeCategory.get(cl.getName()); if (annotationHelper != null) { typeCategory = annotationHelper.getTypeByAnnotation(cl, annotation); } else if (!typeCategory.isSubCategoryOf(TypeCategory.COMPARABLE) && Comparable.class.isAssignableFrom(cl) && !cl.equals(Comparable.class)) { typeCategory = TypeCategory.COMPARABLE; } else if (embeddableTypes.contains(cl)) { typeCategory = TypeCategory.CUSTOM; } else if (typeCategory == TypeCategory.SIMPLE && entity) { typeCategory = TypeCategory.ENTITY; } else if (unknownAsEntity && typeCategory == TypeCategory.SIMPLE && !cl.getName().startsWith("java")) { typeCategory = TypeCategory.CUSTOM; } return new ClassType(typeCategory, cl, parameters); }
/** * transitive and reflexive subCategoryOf check * * @param ancestor * @return */ public boolean isSubCategoryOf(TypeCategory ancestor) { if (this == ancestor) { return true; } else if (superType == null) { return false; } else { return superType == ancestor || superType.isSubCategoryOf(ancestor); } }
public boolean supports(Class<?> cl) { return supports(cl.getName()); }
Type classType = new ClassType(TypeCategory.get(cl.getName()), cl); type.addProperty(new Property(type, StringUtils.uncapitalize(cl.getSimpleName()), classType));
TypeCategory typeCategory = TypeCategory.get(name); typeCategory = TypeCategory.NUMERIC; } else if (!typeCategory.isSubCategoryOf(TypeCategory.COMPARABLE) && isAssignable(typeElement.asType(), comparableType)) { typeCategory = TypeCategory.COMPARABLE;
private void addConstructors(Class<?> cl, EntityType type) { for (Constructor<?> constructor : cl.getConstructors()) { if (constructor.isAnnotationPresent(QueryProjection.class)) { List<Parameter> parameters = Lists.newArrayList(); for (int i = 0; i < constructor.getParameterTypes().length; i++) { Type parameterType = typeFactory.get( constructor.getParameterTypes()[i], constructor.getGenericParameterTypes()[i]); for (Annotation annotation : constructor.getParameterAnnotations()[i]) { if (annotation.annotationType().equals(QueryType.class)) { QueryType queryType = (QueryType) annotation; parameterType = parameterType.as(TypeCategory.valueOf(queryType.value().name())); } } parameters.add(new Parameter("param" + i, parameterType)); } type.addConstructor(new com.mysema.codegen.model.Constructor(parameters)); } } }
Type classType = new ClassType(TypeCategory.get(cl.getName()), cl); type.addProperty(new Property(type, StringUtils.uncapitalize(cl.getSimpleName()), classType));
private Type getType(VariableElement element) { Type rv = typeFactory.getType(element.asType(), true); if (element.getAnnotation(QueryType.class) != null) { QueryType qt = element.getAnnotation(QueryType.class); if (qt.value() != PropertyType.NONE) { TypeCategory typeCategory = TypeCategory.valueOf(qt.value().name()); rv = rv.as(typeCategory); } } return rv; }
@SuppressWarnings("unchecked") @Before public void setUp() { // type Type typeModel = new SimpleType(TypeCategory.ENTITY, "com.querydsl.DomainClass", "com.querydsl", "DomainClass", false, false); type = new EntityType(typeModel); // property type.addProperty(new Property(type, "entityField", type)); type.addProperty(new Property(type, "collection", new ClassType(TypeCategory.COLLECTION, Collection.class, typeModel))); type.addProperty(new Property(type, "listField", new ClassType(TypeCategory.LIST, List.class, typeModel))); type.addProperty(new Property(type, "setField", new ClassType(TypeCategory.SET, Set.class, typeModel))); type.addProperty(new Property(type, "arrayField", new ClassType(TypeCategory.ARRAY, String[].class, typeModel))); type.addProperty(new Property(type, "mapField", new ClassType(TypeCategory.MAP, List.class, typeModel, typeModel))); type.addProperty(new Property(type, "superTypeField", new TypeExtends(new ClassType(TypeCategory.MAP, List.class, typeModel, typeModel)))); type.addProperty(new Property(type, "extendsTypeField", new TypeSuper(new ClassType(TypeCategory.MAP, List.class, typeModel, typeModel)))); for (Class<?> cl : Arrays.asList(Boolean.class, Comparable.class, Integer.class, Date.class, java.sql.Date.class, java.sql.Time.class)) { Type classType = new ClassType(TypeCategory.get(cl.getName()), cl); type.addProperty(new Property(type, StringUtils.uncapitalize(cl.getSimpleName()), classType)); } // constructor Parameter firstName = new Parameter("firstName", new ClassType(TypeCategory.STRING, String.class)); Parameter lastName = new Parameter("lastName", new ClassType(TypeCategory.STRING, String.class)); type.addConstructor(new Constructor(Arrays.asList(firstName, lastName))); }
private Property toProperty(EntityType entityType, String name, TypeMirror type, Annotations annotations) { // type Type propertyType = typeFactory.getType(type, true); if (annotations.isAnnotationPresent(QueryType.class)) { PropertyType propertyTypeAnn = annotations.getAnnotation(QueryType.class).value(); if (propertyTypeAnn != PropertyType.NONE) { TypeCategory typeCategory = TypeCategory.valueOf(annotations.getAnnotation(QueryType.class).value().name()); if (typeCategory == null) { return null; } propertyType = propertyType.as(typeCategory); } else { return null; } } // inits List<String> inits = Collections.emptyList(); if (annotations.isAnnotationPresent(QueryInit.class)) { inits = ImmutableList.copyOf(annotations.getAnnotation(QueryInit.class).value()); } return new Property(entityType, name, propertyType, inits); }
clazz = Object.class; TypeCategory fieldType = TypeCategory.get(clazz.getName()); if (Number.class.isAssignableFrom(clazz)) { fieldType = TypeCategory.NUMERIC;
private Property createProperty(EntityType entityType, String propertyName, Type propertyType, Map<Class<? extends Annotation>, Annotation> annotations) { String[] inits = new String[0]; if (annotations.containsKey(QueryInit.class)) { inits = ((QueryInit) annotations.get(QueryInit.class)).value(); } if (annotations.containsKey(QueryType.class)) { propertyType = propertyType.as(TypeCategory.valueOf(((QueryType) annotations.get(QueryType.class)).value().name())); } Property property = new Property(entityType, propertyName, propertyType, Arrays.asList(inits)); return property; }
clazz = Object.class; TypeCategory fieldType = TypeCategory.get(clazz.getName()); if (Number.class.isAssignableFrom(clazz)) { fieldType = TypeCategory.NUMERIC;
@Nullable protected Type getTypeOverride(Type propertyType, AnnotatedElement annotated) { if (annotated.isAnnotationPresent(QueryType.class)) { QueryType queryType = annotated.getAnnotation(QueryType.class); if (queryType.value().equals(PropertyType.NONE)) { return null; } return propertyType.as(TypeCategory.valueOf(queryType.value().name())); } else { return propertyType; } }
clazz = Object.class; TypeCategory fieldType = TypeCategory.get(clazz.getName()); if (Number.class.isAssignableFrom(clazz)) { fieldType = TypeCategory.NUMERIC;
@Nullable protected Type getTypeOverride(Type propertyType, AnnotatedElement annotated) { if (annotated.isAnnotationPresent(QueryType.class)) { QueryType queryType = annotated.getAnnotation(QueryType.class); if (queryType.value().equals(PropertyType.NONE)) { return null; } return propertyType.as(TypeCategory.valueOf(queryType.value().name())); } else { return propertyType; } }
clazz = Object.class; TypeCategory fieldType = TypeCategory.get(clazz.getName()); if (Number.class.isAssignableFrom(clazz)) { fieldType = TypeCategory.NUMERIC;