@Override public JavaType apply(JavaProperty item) { JavaType nested = SHALLOW_NESTED_TYPE.apply(item); //Not a typical fluent JavaType fluent = TypeAs.UNWRAP_COLLECTION_OF.apply(item.getType()); JavaType superClassFluent = new JavaTypeBuilder(fluent) .withClassName(TypeAs.UNWRAP_COLLECTION_OF.apply(item.getType()) + "Fluent") .withGenericTypes(new JavaType[]{nested}) .build(); return new JavaTypeBuilder(nested) .withGenericTypes(new JavaType[]{N}) .withSuperClass(superClassFluent) .withInterfaces(new HashSet(Arrays.asList(BuilderContextManager.getContext().getNestedInterface().getType()))) .build(); }
public JavaType apply(JavaType item) { if (!GENERIC_MAPPINGS.containsKey(item)) { int iteration = counter / GENERIC_NAMES.length; String name = GENERIC_NAMES[counter % GENERIC_NAMES.length]; if (iteration > 0) { name += iteration; } counter++; GENERIC_MAPPINGS.put(item, new JavaTypeBuilder().withClassName(name).addToAttributes(IS_GENERIC, true).build()); } return GENERIC_MAPPINGS.get(item); }
public JavaType apply(JavaType type) { return new JavaTypeBuilder(type).withArray(false).build(); } };
@Override public JavaType apply(JavaType item) { return new JavaTypeBuilder(Constants.LIST) .withCollection(true) .withGenericTypes(new JavaType[]{item}) .withDefaultImplementation(Constants.ARRAY_LIST) .build(); }
@Override public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } return new JavaTypeBuilder(item) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .build(); } }, INLINEABLE {
public JavaType apply(JavaProperty property) { return new JavaTypeBuilder() .withClassName(captializeFirst(property.getName() + "Nested")) .withGenericTypes(new JavaType[]{N}) .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(); } }
@Override public JavaType apply(JavaType item) { JavaType fluent = SHALLOW_FLUENT.apply(item); List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } return new JavaTypeBuilder(item) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .withSuperClass(typeGenericOf(fluent, SHALLOW_INLINEABLE.apply(item))) .build(); } }, SHALLOW_BUILDER {
@Override public JavaType apply(JavaType... 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) { JavaTypeBuilder builder = new JavaTypeBuilder(items[0]); for (JavaType type : items[1].getInterfaces()) { builder = builder.addToInterfaces(type); } for (JavaType type : items[1].getGenericTypes()) { if (!Arrays.asList(items[0].getGenericTypes()).contains(type)) { builder = builder.addToGenericTypes(type); } } return builder.build(); } else { JavaType[] rest = new JavaType[items.length - 1]; System.arraycopy(items, 1, rest, 0, rest.length); return TYPES.apply(new JavaType[]{items[0], TYPES.apply(rest)}); } } };
public JavaType apply(JavaType type) { Set<JavaType> interfaces = new LinkedHashSet<JavaType>(); Set<JavaType> generics = new LinkedHashSet<JavaType>(); if (GENERIC_MAPPINGS.containsValue(type)) { JavaType unmapped = UNMAP.apply(type); if (!unmapped.equals(type)) { return UNWRAP.apply(unmapped); } return unmapped; } else { for (JavaType iface : type.getInterfaces()) { interfaces.add(UNWRAP.apply(iface)); } for (JavaType generic : type.getGenericTypes()) { generics.add(UNWRAP.apply(generic)); } return new JavaTypeBuilder(type) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .withInterfaces(interfaces) .build(); } } };
@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(); }
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(); }
.withGenericTypes(FLUENT.getGenericTypes()) .and() .build(); .addToModifiers(Modifier.FINAL) .withName("_visitables") .withType(new JavaTypeBuilder(typeGenericOf(LIST, visitableBase)) .withDefaultImplementation(typeGenericOf(ARRAY_LIST, visitableBase)) .build()) .and()
private JavaType replaceGenericWith(JavaType source, JavaType from, JavaType to) { List<JavaType> generics = Arrays.asList(source.getGenericTypes()); if (generics.isEmpty()) { return source; } else if (source.equals(from)) { return to; } else { List<JavaType> updatedGenerics = new ArrayList<JavaType>(); for (JavaType generic : generics) { updatedGenerics.add(replaceGenericWith(generic, from, to)); } return new JavaTypeBuilder(source).withGenericTypes(updatedGenerics.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); } 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 {
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 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(); } },
@Override public JavaMethod apply(JavaProperty property) { String methodName = "with" + property.getNameCapitalized(); JavaType unwraped = combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF).apply(property.getType()); String addToMethodName = "addTo" + property.getNameCapitalized(); JavaProperty arrayProperty = new JavaPropertyBuilder(property) .withType(new JavaTypeBuilder(unwraped) .withArray(true) .build()) .withArray(true) .build(); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withName(methodName) .withReturnType(T) .withArguments(new JavaProperty[]{arrayProperty}) .addToAttributes(BODY, "this." + property.getName() + ".clear(); if (" + property.getName() + " != null) {for (" + unwraped.getSimpleName() + " item :" + property.getName() + "){ this." + addToMethodName + "(item);}} return (T) this;") .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 {