@Override public String apply(JavaClazz item) { return item.getType().getSimpleName(); } }, "#");
private static boolean canBeExcluded(JavaClazz candidate, Iterable<JavaClazz> provided) { Set<JavaType> allOther = new LinkedHashSet<JavaType>(); for (JavaClazz c : provided) { if (!c.equals(candidate)) { allOther.addAll(JavaTypeUtils.extractInterfaces(c.getType())); } } Set<JavaType> allProvided = JavaTypeUtils.extractInterfaces(allOther); for (JavaType type : JavaTypeUtils.extractInterfaces(candidate.getType())) { if (!allProvided.contains(type)) { return false; } } return true; }
private static Set<JavaClazz> exclusion(Set<JavaClazz> one, Set<JavaType> excluded) { Set<JavaClazz> result = new LinkedHashSet<JavaClazz>(); for (JavaClazz item : one) { if (!excluded.contains(item.getType()) || isTerminal(item) || isCardinalityMultiple(item)) { result.add(item); } } return result; }
private static boolean isSatisfied(JavaClazz candidate, Set<JavaType> visited) { Set<String> visitedKeywords = getKeywords(visited); Boolean multiple = (Boolean) candidate.getType().getAttributes().get(CARDINALITY_MULTIPLE); Set<String> requiresAll = (Set<String>) candidate.getType().getAttributes().get(REQUIRES_ALL); Set<String> requiresAny = (Set<String>) candidate.getType().getAttributes().get(REQUIRES_ANY); Set<String> exclusive = (Set<String>) candidate.getType().getAttributes().get(EXCLUSIVE); //Eliminate circles if not supported if (!multiple && visited.contains(candidate.getType())) { return false; } //Check if path contains exclusive keywords for (String e : exclusive) { if (visitedKeywords.contains(e)) { return false; } } //Check if "All" requirements are meet for (String a : requiresAll) { if (!visitedKeywords.contains(a)) { return false; } } for (String a : requiresAny) { if (visitedKeywords.contains(a)) { return true; } } return requiresAny.isEmpty(); }
private static String toBuild(JavaClazz clazz) { JavaMethod constructor = findBuildableConstructor(clazz); StringBuilder sb = new StringBuilder(); sb.append(clazz.getType().getSimpleName()).append(" buildable = new ").append(clazz.getType().getSimpleName()).append("("); sb.append(StringUtils.join(constructor.getArguments(), new Function<JavaProperty, String>() { @Override public String apply(JavaProperty item) { String prefix = item.getType().isBoolean() ? "is" : "get"; return "fluent." + prefix + item.getNameCapitalized() + "()"; } }, ",")); sb.append(");\n"); sb.append("validate(buildable);\n"); sb.append("return buildable;\n"); return sb.toString(); }
/** * Convert a {@link Collection} of {@link javax.lang.model.element.ExecutableElement}s to a {@link java.util.Set} of {@link io.sundr.codegen.model.JavaClazz}es. * * @param context The context of the operation. * @param elements The target elements. * @return A set of {@link io.sundr.codegen.model.JavaClazz} that describes the interfaces. */ public static Set<JavaClazz> executablesToInterfaces(DslProcessorContext context, Collection<ExecutableElement> elements) { Map<String, JavaClazz> byName = new LinkedHashMap<String, JavaClazz>(); for (ExecutableElement current : elements) { JavaClazz clazz = executableToInterface(context, current); InterfaceName interfaceName = current.getAnnotation(InterfaceName.class); String name = interfaceName != null ? clazz.getType().getPackageName() + "." + interfaceName.value() : clazz.getType().getFullyQualifiedName(); if (byName.containsKey(name)) { JavaClazz other = byName.remove(name); byName.put(name, Merge.CLASSES.apply(new JavaClazz[]{other, clazz})); } else { byName.put(name, clazz); } } return new LinkedHashSet<JavaClazz>(byName.values()); }
@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; }
@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 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(); }
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 baseType = TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF).apply(item); // if (!baseType.isConcrete()) { // baseType = typeExtends(Q, baseType); // } return new JavaTypeBuilder(BuilderContextManager.getContext().getVisitableBuilderInterface().getType()) .withGenericTypes(new JavaType[]{baseType, Q}) .build(); } },
@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 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(); }