@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 {
@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 {
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(); } } };
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(); }
@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 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(); }