public JavaType apply(JavaType type) { if (type.isCollection()) { return type.getGenericTypes()[0]; } else { return type; } }
@Override public JavaType apply(String fullName) { JavaType type = delegate.apply(fullName); if (type == null) { return null; } TypeElement typeElement = elements.getTypeElement(fullName); boolean isBuildable = false; if (fullName.endsWith("[]")) { typeElement = elements.getTypeElement(fullName.substring(0, fullName.length() - 2)); isBuildable = isBuildable(typeElement); } else if (type.isCollection()) { for (JavaType genericType : type.getGenericTypes()) { isBuildable = isBuildable(elements.getTypeElement(genericType.getFullyQualifiedName())); } } else { isBuildable = isBuildable(typeElement); } Map<String, Object> attributes = new HashMap<String, Object>(type.getAttributes()); attributes.put(BUILDABLE, isBuildable); return new JavaTypeBuilder(type).withAttributes(attributes).build(); }
private String getBody(JavaProperty property) { String name = property.getName(); JavaType type = property.getType(); String className = type.getClassName(); StringBuilder sb = new StringBuilder(); if (type.isCollection()) { sb.append("this." + name + ".clear();"); if (className.contains("Map")) { sb.append("if (" + name + " != null) {this." + name + ".putAll(" + name + ");} return (T) this;"); } else if (className.contains("List") || className.contains("Set")) { JavaType unwraped = TypeAs.UNWRAP_COLLECTION_OF.apply(property.getType()); String addToMethodName = "addTo" + property.getNameCapitalized(); sb.append("if (" + name + " != null) {for (" + unwraped.getSimpleName() + " item : " + name + "){this." + addToMethodName + "(item);}} return (T) this;"); } return sb.toString(); } else if (isBuildable(property)) { JavaType builder = combine(UNWRAP_COLLECTION_OF, BUILDER).apply(property.getType()); String propertyName = property.getName(); String builderClass = builder.getSimpleName(); return "if (" + propertyName + "!=null){ this." + propertyName + "= new " + builderClass + "(" + propertyName + "); _visitables.add(this." + propertyName + ");} return (T) this;"; } return "this." + property.getName() + "=" + property.getName() + "; return (T) this;"; }
@Override public Set<JavaMethod> apply(JavaProperty property) { Set<JavaMethod> result = new LinkedHashSet<JavaMethod>(); JavaClazz clazz = PropertyAs.CLASS.apply(property); for (JavaMethod constructor : getInlineableConstructors(property)) { String ownPrefix = property.getType().isCollection() ? "addNew" : "withNew"; String ownName = ownPrefix + captializeFirst(property.getType().isCollection() ? singularize(property.getName()) : property.getName()); String delegatePrefix = property.getType().isCollection() ? "addTo" : "with"; String delegateName = delegatePrefix + captializeFirst(property.getName()); String args = StringUtils.join(constructor.getArguments(), new Function<JavaProperty, String>() { @Override public String apply(JavaProperty item) { return item.getName(); } }, ", "); result.add(new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(T) .withArguments(constructor.getArguments()) .withName(ownName) .addToAttributes(BODY, "return " + delegateName + "(new " + clazz.getType().getSimpleName() + "(" + args + "));") .build()); } return result; } };
@Override public JavaMethod apply(JavaProperty property) { //We need to repackage because we are nesting under this class. JavaType nestedType = PropertyAs.NESTED_TYPE.apply(property); JavaType rewraped = new JavaTypeBuilder(nestedType).withGenericTypes(new JavaType[]{T}).build(); String prefix = property.getType().isCollection() ? "addNew" : "withNew"; String methodName = prefix + captializeFirst(property.getType().isCollection() ? singularize(property.getName()) : property.getName()); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(rewraped) .withName(methodName) .addToAttributes(BODY, "return new " + rewraped.getSimpleName() + "();") .build(); } }, WITH_NEW_LIKE_NESTED {
methods.add(ToMethod.WITH_NEW_NESTED.apply(toAdd)); methods.add(ToMethod.WITH_NEW_LIKE_NESTED.apply(toAdd)); if (!toAdd.getType().isCollection() && !toAdd.isArray()) { methods.add(ToMethod.EDIT_NESTED.apply(toAdd)); if (toAdd.getType().isCollection()) { builderType = typeGenericOf(toAdd.getType(), builderType); } else if (descendants.size() > 0 && toAdd.getType().isCollection()) { properties.add(toAdd); if (descendant.getType().isCollection()) { methods.add(ToMethod.ADD_TO_COLLECTION.apply(descendant)); methods.add(ToMethod.REMOVE_FROM_COLLECTION.apply(descendant)); if (descendant.getType().isCollection()) { builderType = typeGenericOf(descendant.getType(), builderType);
@Override public JavaMethod apply(JavaProperty property) { String methodName = "end" + captializeFirst(property.getType().isCollection() ? singularize(property.getName()) : property.getName()); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(N) .withName(methodName) .addToAttributes(BODY, "return and();") .build(); } };
@Override public JavaMethod apply(JavaProperty property) { String builderName = TypeAs.UNWRAP_COLLECTION_OF.apply(property.getType()).getSimpleName("Builder"); String classPrefix = getClassPrefix(property); String prefix = property.getType().isCollection() ? "addTo" : "with"; String withMethodName = prefix + captializeFirst(property.getName()); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(N) .withName("and") .addToAttributes(BODY, "return (N) " + classPrefix + withMethodName + "(builder.build());") .build(); }
JavaType baseType = property.getType(); if (baseType.isCollection()) { JavaType candidate = TypeAs.UNWRAP_COLLECTION_OF.apply(baseType); for (JavaType descendant : BuilderUtils.getBuildableDescendants(candidate)) {
@Override public JavaMethod apply(JavaProperty property) { JavaType baseType = TypeAs.UNWRAP_COLLECTION_OF.apply(property.getType()); JavaType nestedType = PropertyAs.NESTED_TYPE.apply(property); //JavaType nestedUnwrapped = new JavaTypeBuilder(nestedType).withGenericTypes(new JavaType[0]).build(); //We need to repackage because we are nesting under this class. JavaType rewraped = new JavaTypeBuilder(nestedType).withGenericTypes(new JavaType[]{T}).build(); String prefix = property.getType().isCollection() ? "addNew" : "withNew"; String suffix = "Like"; String methodName = prefix + captializeFirst(property.getType().isCollection() ? singularize(property.getName()) : property.getName()) + suffix; return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(rewraped) .withName(methodName) .addNewArgument() .withName("item") .withType(baseType) .endArgument() .addToAttributes(BODY, "return new " + rewraped.getSimpleName() + "(item);") .build(); } }, EDIT_NESTED {