@Override public JavaClazz apply(JavaClazz item) { JavaType type = item.getType(); JavaType editableType = TypeAs.EDITABLE.apply(type); JavaType builderType = TypeAs.BUILDER.apply(type); Set<JavaMethod> constructors = new LinkedHashSet<JavaMethod>(); Set<JavaMethod> methods = new LinkedHashSet<JavaMethod>(); for (JavaMethod constructor : item.getConstructors()) { constructors.add(superConstructorOf(constructor, editableType)); } JavaMethod edit = new JavaMethodBuilder() .withReturnType(builderType) .withName("edit") .addToAttributes(BODY, "return new " + builderType.getSimpleName() + "(this);") .build(); methods.add(edit); return new JavaClazzBuilder() .withType(editableType) .withConstructors(constructors) .withMethods(methods) .build(); } }, INLINEABLE {
@Override public JavaClazz apply(JavaClazz... items) { if (items == null || items.length == 0) { throw new IllegalArgumentException("Items cannot be empty."); } else if (items.length == 1) { return items[0]; } else if (items.length == 2) { JavaType mergedType = TYPES.apply(new JavaType[]{items[0].getType(), items[1].getType()}); JavaClazzBuilder builder = new JavaClazzBuilder(items[0]).withType(mergedType); for (JavaMethod constructor : items[1].getConstructors()) { builder = builder.addToConstructors(constructor); } for (JavaMethod method : items[1].getMethods()) { builder = builder.addToMethods(method); } for (JavaProperty property : items[1].getFields()) { builder = builder.addToFields(property); } return builder.build(); } else { JavaClazz[] rest = new JavaClazz[items.length - 1]; System.arraycopy(items, 1, rest, 0, rest.length); CLASSES.apply(new JavaClazz[]{items[0], CLASSES.apply(rest)}); } return null; } };
@Override public Set<JavaClazz> apply(Set<JavaClazz> source) { Set<JavaClazz> result = new LinkedHashSet<JavaClazz>(source); Set<JavaType> generifiableTypes = findGenerifiables(source); for (JavaType type : generifiableTypes) { Set<JavaClazz> intermediate = new LinkedHashSet<JavaClazz>(); for (JavaClazz clazz : result) { intermediate.add(new JavaClazzBuilder(clazz).withType(replaceGenericWith(clazz.getType(), type, Generics.MAP.apply(type))).build()); } result = new LinkedHashSet<JavaClazz>(intermediate); } return result; }
.withName("equals") .addToAttributes(BODY, toEquals(fluentType, properties)) .build(); return new JavaClazzBuilder(item) .withType(fluentType) .withFields(properties) .withNested(nestedClazzes) .withMethods(methods) .build();
visitorInterface = new JavaClazzBuilder() .withNewType() .withKind(JavaKind.INTERFACE) .withPackageName(builderPackage) .withGenericTypes(VISITOR.getGenericTypes()) .and() .addNewMethod() .addToModifiers(Modifier.PUBLIC) .withReturnType(VOID) .endArgument() .and() .build(); visitableInterface = new JavaClazzBuilder() .withNewType() .withKind(JavaKind.INTERFACE) .withPackageName(builderPackage) .withGenericTypes(new JavaType[]{V}) .and() .addNewMethod() .addToModifiers(Modifier.PUBLIC) .withReturnType(V) .endArgument() .and() .build();
interfacesToGenerate.add(new JavaClazzBuilder() .withNewType() .withPackageName(ModelUtils.getPackageElement(element).toString()) .withClassName(targetInterface) .withKind(JavaKind.INTERFACE) .and() .withMethods(methods) .build());
@Override public JavaClazz apply(JavaClazz item) { JavaClazz builder = BUILDER.apply(item); Set<JavaMethod> methods = new LinkedHashSet<JavaMethod>(); for (JavaMethod m : builder.getMethods()) { if (m.getName().equals("build")) { methods.add(new JavaMethodBuilder() .withReturnType(TypeAs.EDITABLE.apply(m.getReturnType())) .withName("build") .addToAttributes(BODY, toBuild(EDITABLE.apply(item))) .build()); } else { methods.add(m); } } return new JavaClazzBuilder(builder) .withMethods(methods) .build(); } }, EDITABLE {
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(); }
JavaClazz combination = new JavaClazzBuilder() .withNewType() .withKind(JavaKind.INTERFACE) .withClassName(className) .addToAttributes(IS_COMPOSITE, false) .endType() .build();
toInterfaceName(targetMethod.getName()); return new JavaClazzBuilder() .withNewType() .withPackageName(ModelUtils.getPackageElement(executableElement).toString()) .withClassName(interfaceName) .addToAttributes(METHOD_NAME, methodName) .endType() .addToMethods(targetMethod) .build();
public static JavaClazz transition(JavaClazz from, JavaClazz to) { JavaType transitionInterface = new JavaTypeBuilder(from.getType()) .withGenericTypes(new JavaType[]{to.getType()}).build(); return new JavaClazzBuilder(from) .withType(transitionInterface) .build(); }
public static JavaClazz createRootInterface(Node<JavaClazz> current, Set<JavaClazz> intermediate) { JavaClazz rootInterface = null; Set<JavaType> interfaces = new LinkedHashSet<JavaType>(); for (Node<JavaClazz> child : current.getTransitions()) { JavaClazz transitionInterface = createTransitionInterface(child, intermediate); interfaces.add(transitionInterface.getType()); intermediate.add(transitionInterface); intermediate.add(child.getItem()); } JavaType rootType = new JavaTypeBuilder(current.getItem().getType()) .withInterfaces(interfaces) .withGenericTypes(new JavaType[]{}) .build(); return new JavaClazzBuilder(current.getItem()) .withType(Generics.UNWRAP.apply(rootType)) .withMethods(new LinkedHashSet<JavaMethod>()) .build(); }
.addToModifiers(Modifier.PUBLIC) .addToAttributes(BODY, "this.builder=new "+builderType.getSimpleName()+"(this);this.visitor=visitor;") .build(); return new JavaClazzBuilder() .withType(updateableType) .addToConstructors(constructor1) .addToConstructors(constructor2) .addToFields(builderProperty) .addToFields(visitorProperty) .addToMethods(update) .build();
.withName("") .withReturnType(nestedUnwrapped) .addToAttributes(BODY, "this.builder = new " + builderType.getSimpleName() + "(this);") .build()); return new JavaClazzBuilder() .withType(nestedType) .withFields(properties) .withMethods(nestedMethods) .withConstructors(constructors) .addToAttributes(MEMBER_OF, memberOf) .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(); } }
.withName("equals") .addToAttributes(BODY, toEquals(builderType, fields)) .build(); return new JavaClazzBuilder(item) .withType(builderType) .withFields(fields) .withConstructors(constructors) .withMethods(methods) .build();