public static JavaMethod findGetter(JavaClazz clazz, JavaProperty property) { for (JavaMethod method : clazz.getMethods()) { if (isApplicableGetterOf(method, property)) { return method; } } return null; }
for (Node<JavaClazz> root : graph) { JavaClazz current = root.getItem(); for (JavaMethod m : current.getMethods()) { methods.add(new JavaMethodBuilder(m).withReturnType(current.getType()).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 {
@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; } };
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(); } }