private boolean hasPropertyWithType(TypeCategory category) { for (Property property : properties) { if (property.getType().getCategory() == category) { return true; } } return false; }
private Type getQueryType(Map<TypeCategory, Type> types, Type type, EntityType model, boolean raw, boolean rawParameters, boolean extend) { Type exprType = types.get(type.getCategory()); return getQueryType(type, model, exprType, raw, rawParameters, extend); }
@Override public TypeCategory getCategory() { if (getType().getCategory() == TypeCategory.ENTITY || !properties.isEmpty()) { return TypeCategory.ENTITY; } else { return TypeCategory.CUSTOM; } }
@Nullable private Type createType(TypeMirror typeMirror, List<String> key, boolean deep) { typeCache.put(key, null); Type type = visitor.visit(typeMirror, deep); if (type != null && (type.getCategory() == TypeCategory.ENTITY || type.getCategory() == TypeCategory.CUSTOM)) { EntityType entityType = getEntityType(typeMirror, deep); typeCache.put(key, entityType); return entityType; } else { typeCache.put(key, type); 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); }
private Type createWithoutPackage(Type type) { String simpleName = prefix + normalizeName(type.getFullName()) + suffix; return new SimpleType(type.getCategory(), simpleName, "", simpleName, false, false); }
protected void addToString(EntityType model, CodeWriter writer) throws IOException { writer.line("@Override"); writer.beginPublicMethod(Types.STRING, "toString"); StringBuilder builder = new StringBuilder(); for (Property property : model.getProperties()) { String propertyName = property.getEscapedName(); if (builder.length() > 0) { builder.append(" + \", "); } else { builder.append("\""); } builder.append(propertyName + " = \" + "); if (property.getType().getCategory() == TypeCategory.ARRAY) { builder.append("Arrays.toString(" + propertyName + ")"); } else { builder.append(propertyName); } } writer.line(" return ", builder.toString(), ";"); writer.end(); }
protected boolean hasOwnEntityProperties(EntityType model) { if (model.hasEntityFields()) { for (Property property : model.getProperties()) { if (!property.isInherited() && property.getType().getCategory() == TypeCategory.ENTITY) { return true; } } } return false; }
@Test public void simpleType() { for (Class<?> cl : Arrays.<Class<?>>asList(Blob.class, Clob.class, Locale.class, Class.class, Serializable.class)) { assertEquals("wrong type for " + cl.getName(), TypeCategory.SIMPLE, factory.get(cl).getCategory()); } }
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); } }
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;
if (property.getType().getCategory() == TypeCategory.CUSTOM) { Set<TypeElement> customElements = context.typeElements.get(property.getType().getFullName()); if (customElements != null) {
@Test public void numberType() { for (Class<?> cl : Arrays.<Class<?>>asList(Byte.class, Integer.class)) { assertEquals("wrong type for " + cl.getName(), TypeCategory.NUMERIC, factory.get(cl).getCategory()); } }
@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()); }
@Test public void enumType() { assertEquals(TypeCategory.ENUM, factory.get(EnumExample.class).getCategory()); }
@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()); }
@Test public void unknownAsEntity() { assertEquals(TypeCategory.SIMPLE, factory.get(TypeFactoryTest.class).getCategory()); factory = new TypeFactory(); factory.setUnknownAsEntity(true); assertEquals(TypeCategory.CUSTOM, factory.get(TypeFactoryTest.class).getCategory()); }
protected void initEntityFields(CodeWriter writer, SerializerConfig config, EntityType model) throws IOException { Supertype superType = model.getSuperType(); if (superType != null) { EntityType entityType = superType.getEntityType(); if (entityType != null && entityType.hasEntityFields()) { Type superQueryType = typeMappings.getPathType(entityType, model, false); writer.line("this._super = new " + writer.getRawName(superQueryType) + "(type, metadata, inits);"); } } for (Property field : model.getProperties()) { if (field.getType().getCategory() == TypeCategory.ENTITY) { initEntityField(writer, config, model, field); } else if (field.isInherited() && superType != null && superType.getEntityType().hasEntityFields()) { writer.line("this.", field.getEscapedName(), " = _super.", field.getEscapedName(), SEMICOLON); } } }
@Override public void serialize(EntityType model, SerializerConfig config, CodeWriter writer) throws IOException { intro(model, config, writer); // properties serializeProperties(model, config, writer); // constructors constructors(model, config, writer); // delegates for (Delegate delegate : model.getDelegates()) { delegate(model, delegate, config, writer); } // property accessors for (Property property : model.getProperties()) { TypeCategory category = property.getType().getCategory(); if (category == TypeCategory.MAP && config.useMapAccessors()) { mapAccessor(model, property, writer); } else if (category == TypeCategory.LIST && config.useListAccessors()) { listAccessor(model, property, writer); } else if (category == TypeCategory.ENTITY && config.useEntityAccessors()) { entityAccessor(model, property, writer); } } outro(model, writer); }
@Test public void boolean_() { Type bo = factory.get(boolean.class); assertEquals(TypeCategory.BOOLEAN, bo.getCategory()); assertEquals("Boolean", bo.getSimpleName()); assertEquals("java.lang.Boolean", bo.getFullName()); assertEquals("java.lang", bo.getPackageName()); }