@Override public String apply(JavaType item) { return stripSuffix(item.getClassName()); } };
private String getClassPrefix(JavaProperty property) { Object memberOf = property.getAttributes().get(MEMBER_OF); if (memberOf instanceof JavaType) { return ((JavaType) memberOf).getClassName() + ".this."; } else return ""; }
@Override public String apply(JavaType item) { return stripSuffix(item.getClassName()).substring(prefix.length()); } }, "Or"));
private static String toEquals(JavaType type, Collection<JavaProperty> properties) { String simpleName = type.getClassName(); JavaType superClass = type.getSuperClass(); StringBuilder sb = new StringBuilder(); sb.append("\n"); sb.append("if (this == o) return true;").append("\n"); sb.append("if (o == null || getClass() != o.getClass()) return false;").append("\n"); //If base fluent is the superclass just skip. if (!Constants.BASE_FLUENT.getClassName().equals(superClass.getClassName())) { sb.append("if (!super.equals(o)) return false;").append("\n"); } sb.append(simpleName).append(" that = (").append(simpleName).append(") o;").append("\n"); for (JavaProperty property : properties) { String name = property.getName(); if (BuilderUtils.isPrimitive(property.getType())) { sb.append("if (").append(name).append(" != ").append("that.").append(name).append(") return false;").append("\n"); } else if (BuilderUtils.isDescendant(type, property.getType())) { sb.append("if (").append(name).append(" != null &&").append(name).append(" != this ? !").append(name).append(".equals(that.").append(name).append(") :") .append("that.").append(name).append(" != null &&").append(name).append(" != this ) return false;").append("\n"); } else { sb.append("if (").append(name).append(" != null ? !").append(name).append(".equals(that.").append(name).append(") :") .append("that.").append(name).append(" != null) return false;").append("\n"); } } sb.append("return true;").append("\n"); return sb.toString(); }
public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } generics.add(Constants.T); return new JavaTypeBuilder(item) .withClassName(item.getClassName() + "Fluent") .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .build(); } },
public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } generics.add(Constants.Q); return new JavaTypeBuilder(item) .withClassName(item.getClassName() + "Fluent") .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .build(); } },
public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } return new JavaTypeBuilder(item) .withClassName(item.getClassName() + "Builder") .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .build(); }
@Override public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } JavaType builder = SHALLOW_BUILDER.apply(item); generics.add(builder); JavaType fluent = typeGenericOf(SHALLOW_FLUENT.apply(item), generics.toArray(new JavaType[generics.size()])); generics.remove(builder); return new JavaTypeBuilder(item) .withClassName(item.getClassName() + "Builder") .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .withSuperClass(fluent) .withInterfaces(new HashSet(Arrays.asList(typeGenericOf(BuilderContextManager.getContext().getVisitableBuilderInterface().getType(), item, builder)))) .build(); } }, EDITABLE {
@Override public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } return new JavaTypeBuilder(item) .withClassName("Editable" + item.getClassName()) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .withSuperClass(item) .withInterfaces(new HashSet(Arrays.asList(typeGenericOf(BuilderContextManager.getContext().getEditableInterface().getType(), SHALLOW_BUILDER.apply(item))))) .build(); } }, SHALLOW_INLINEABLE {
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 JavaType apply(JavaType item) { BuilderContext ctx = BuilderContextManager.getContext(); JavaType fluent = SHALLOW_FLUENT.apply(item); List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } JavaType generic = typeExtends(Constants.T, fluent); generics.add(generic); JavaType superClass = isBuildable(item.getSuperClass()) ? SHALLOW_FLUENT.apply(item.getSuperClass()) : ctx.getBaseFluentClass().getType(); return new JavaTypeBuilder(item) .withClassName(item.getClassName() + "Fluent") .withPackageName(item.getPackageName()) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .withSuperClass(superClass) .withInterfaces(new HashSet(Arrays.asList(ctx.getFluentInterface().getType()))) .build(); }
@Override public JavaMethod apply(JavaProperty property) { String prefix = property.getType().isBoolean() ? "is" : "get"; String methodName = prefix + property.getNameCapitalized(); JavaType type = property.getType(); Boolean isBuildable = isBuildable(type); JavaType targetType = isBuildable ? VISITABLE_BUILDER.apply(type) : TypeAs.UNWRAP_ARRAY_OF.apply(type); String body = String.format(isBuildable ? BUILDABLE_ARRAY_GETTER_TEXT : SIMPLE_ARRAY_GETTER_TEXT,type.getClassName(), targetType.getSimpleName(), property.getName(), type.getClassName()); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withName(methodName) .withReturnType(property.getType()) .withArguments(new JavaProperty[]{}) .addToAttributes(BODY, body) .build(); } },
JavaClazz inlineableOf(BuilderContext ctx, JavaClazz clazz, Inline inline) { JavaClazz base = ClazzAs.INLINEABLE.apply(clazz); JavaType baseInterface = typeGenericOf(BuilderUtils.getInlineType(ctx, inline), clazz.getType()); JavaMethod method = new JavaMethodBuilder(base.getMethods().iterator().next()).withName(inline.value()).build(); JavaType fluent = TypeAs.SHALLOW_FLUENT.apply(clazz.getType()); JavaType shallowInlineType = new JavaTypeBuilder(base.getType()) .withClassName(inline.prefix() + base.getType().getClassName() + inline.suffix()) .addToInterfaces(baseInterface) .build(); JavaType inlineType = new JavaTypeBuilder(shallowInlineType) .withSuperClass(typeGenericOf(fluent, shallowInlineType)) .build(); Set<JavaMethod> constructors = new LinkedHashSet<JavaMethod>(); for (JavaMethod constructor : base.getConstructors()) { constructors.add(new JavaMethodBuilder(constructor).withReturnType(inlineType).build()); } return new JavaClazzBuilder(base) .withType(inlineType) .withConstructors(constructors) .withMethods(new HashSet<JavaMethod>(Arrays.asList(method))) .build(); } }
public JavaClazz getInlineableInterface(Inline inline) { return new JavaClazzBuilder() .withNewType() .withKind(JavaKind.INTERFACE) .withPackageName(builderPackage) .withClassName(inline.prefix() + INLINEABLE.getClassName() + inline.suffix()) .withGenericTypes(INLINEABLE.getGenericTypes()) .and() .addNewMethod() .withReturnType(T) .withName(inline.value()) .and() .build(); }
.addToAttributes(BODY, hasDefaultConstructor(item) ? "this(new " + item.getType().getClassName() + "());" : "this.fluent = this;") .build(); .withName("fluent") .and() .addToAttributes(BODY, hasDefaultConstructor(item) ? "this(fluent, new " + item.getType().getClassName() + "());" : "this.fluent = fluent;") .build();
.withKind(JavaKind.INTERFACE) .withPackageName(builderPackage) .withClassName(VISITOR.getClassName()) .withGenericTypes(VISITOR.getGenericTypes()) .and() .withKind(JavaKind.INTERFACE) .withPackageName(builderPackage) .withClassName(VISITABLE.getClassName()) .withGenericTypes(new JavaType[]{V}) .and() .withPackageName(builderPackage) .withKind(JavaKind.INTERFACE) .withClassName(BUILDER.getClassName()) .withGenericTypes(BUILDER.getGenericTypes()) .and() .withKind(JavaKind.INTERFACE) .withPackageName(builderPackage) .withClassName(FLUENT.getClassName()) .withGenericTypes(FLUENT.getGenericTypes()) .and() .withKind(JavaKind.CLASS) .withPackageName(builderPackage) .withClassName(BASE_FLUENT.getClassName()) .withGenericTypes(BASE_FLUENT.getGenericTypes()) .addToInterfaces(fluentInterface.getType())