try { Type type = conf.getTypeMappings().getPathType(model, model, true); String packageName = type.getPackageName(); String className = !packageName.isEmpty() ? (packageName + "." + type.getSimpleName()) : type.getSimpleName(); if (property.getType().getCategory() == TypeCategory.CUSTOM) { Set<TypeElement> customElements = context.typeElements.get(property.getType().getFullName()); if (customElements != null) { elements.addAll(customElements);
private void addSupertypeFields(EntityType model, Map<String, EntityType> superTypes, Set<EntityType> handled) { if (handled.add(model)) { for (Supertype supertype : model.getSuperTypes()) { EntityType entityType = superTypes.get(supertype.getType().getFullName()); if (entityType == null) { if (supertype.getType().getPackageName().startsWith("java.")) { // skip internal supertypes continue; } // FIXME this misses the generics Class<?> cl = supertype.getType().getJavaClass(); typeFactory.addEmbeddableType(cl); entityType = createEntityType(cl, new HashMap<Class<?>, EntityType>()); addProperties(cl, entityType); } addSupertypeFields(entityType, superTypes, handled); supertype.setEntityType(entityType); model.include(supertype); } } }
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 getRaw(Type type) { if (type instanceof EntityType && type.getPackageName().startsWith("ext.java")) { return type; } else { return new SimpleType(type, type.getParameters()); } }
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 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); }
@Test public void blob() { Type blob = factory.get(Blob.class); assertEquals("Blob", blob.getSimpleName()); assertEquals("java.sql.Blob", blob.getFullName()); assertEquals("java.sql", blob.getPackageName()); }
@Override public String toString() { return delegateType.getFullName() + "." + name + " " + parameters; }
@Test public void generics_wildcard() throws SecurityException, NoSuchFieldException { Field field = DefaultQueryMetadata.class.getDeclaredField("exprInJoins"); Type type = factory.get(field.getType(), field.getGenericType()); assertEquals(TypeCategory.SET, type.getCategory()); Type parameter = type.getParameters().get(0); assertEquals(Expression.class, parameter.getJavaClass()); parameter = parameter.getParameters().get(0); assertEquals(TypeExtends.class, parameter.getClass()); assertNull(((TypeExtends) parameter).getVarName()); }
private void serialize(Serializer serializer, Map<Class<?>, EntityType> types) throws IOException { for (Map.Entry<Class<?>, EntityType> entityType : types.entrySet()) { Type type = typeMappings.getPathType(entityType.getValue(), entityType.getValue(), true); String packageName = type.getPackageName(); String className = packageName.length() > 0 ? (packageName + "." + type.getSimpleName()) : type.getSimpleName(); SerializerConfig config = serializerConfig; if (entityType.getKey().isAnnotationPresent(Config.class)) { config = SimpleSerializerConfig.getConfig(entityType.getKey().getAnnotation(Config.class)); } String fileSuffix = createScalaSources ? ".scala" : ".java"; write(serializer, className.replace('.', '/') + fileSuffix, config, entityType.getValue()); } }
private boolean hasPropertyWithType(TypeCategory category) { for (Property property : properties) { if (property.getType().getCategory() == category) { return true; } } return false; }
&& !queryType.getPackageName().equals(model.getPackageName()) && !queryType.getSimpleName().equals(model.getSimpleName())) { String fullName = model.getFullName(); String packageName = model.getPackageName(); Set<TypeCategory> collections = Sets.newHashSet(TypeCategory.COLLECTION, TypeCategory.LIST, TypeCategory.SET); for (Property property : model.getProperties()) { if (!property.isInherited() && collections.contains(property.getType().getCategory())) { inits = true; break;
private Type createWithoutPackage(Type type) { String simpleName = prefix + normalizeName(type.getFullName()) + suffix; return new SimpleType(type.getCategory(), simpleName, "", simpleName, false, false); }
@Override public int compareTo(EntityType o) { return getType().getSimpleName().compareTo(o.getType().getSimpleName()); }
public Type getParameter(int i) { return type.getParameters().get(i); }
private Type getPropertyType(org.hibernate.mapping.Property p, Type propertyType) { switch (propertyType.getCategory()) { case DATE: case TIME: case DATETIME: String type = p.getType().getName(); if ("time".equals(type)) { propertyType = propertyType.as(TypeCategory.TIME); } else if ("date".equals(type)) { propertyType = propertyType.as(TypeCategory.DATE); } else if ("timestamp".equals(type)) { propertyType = propertyType.as(TypeCategory.DATETIME); } default: } return propertyType; }
private Set<String> getUsedClassNames(EntityType model) { Set<String> result = Sets.newHashSet(); result.add(model.getSimpleName()); for (Property property : model.getProperties()) { result.add(property.getType().getSimpleName()); for (Type type : property.getType().getParameters()) { if (type != null) { result.add(type.getSimpleName()); } } } return result; }
@Test public void simpleTypes_classList5() throws SecurityException, NoSuchFieldException { Field field = Examples.SimpleTypes.class.getDeclaredField("classList5"); Type type = factory.get(field.getType(), field.getGenericType()); assertEquals(TypeCategory.LIST, type.getCategory()); Type parameter = type.getParameters().get(0); assertEquals(ClassType.class, parameter.getClass()); assertEquals(TypeExtends.class, parameter.getParameters().get(0).getClass()); }
&& property.getType().getCategory() != TypeCategory.CUSTOM && property.getType().getCategory() != TypeCategory.ENTITY) { customField(model, property, config, writer); continue; Type propertyType = new SimpleType(property.getType(), property.getType().getParameters()); Type queryType = typeMappings.getPathType(propertyType, model, false); Type genericQueryType = null; String inits = getInits(property); switch (property.getType().getCategory()) { case STRING: serialize(model, property, queryType, writer, "createString"); serialize(model, property, new ClassType(ArrayPath.class, property.getType(), wrap(property.getType().getComponentType())), writer, "createArray", writer.getClassConstant(localRawName)); break;
protected void introPackage(CodeWriter writer, EntityType model) throws IOException { Type queryType = typeMappings.getPathType(model, model, false); if (!queryType.getPackageName().isEmpty()) { writer.packageDecl(queryType.getPackageName()); } }