public JavaType apply(JavaType type) { if (type.isCollection()) { return type.getGenericTypes()[0]; } else { return type; } }
private static void popullateGenericTypes(JavaType type, Set<JavaType> result) { for (JavaType generic : type.getGenericTypes()) { popullateGenericTypes(generic, result); } result.add(type); }
private Set<JavaType> getGenericReferences(JavaType type) { Set<JavaType> result = new LinkedHashSet<JavaType>(); if (JavaTypeUtils.isGeneric(type)) { result.add(type); } else { for (JavaType t : type.getGenericTypes()) { result.addAll(getGenericReferences(t)); } } 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) .withGenericTypes(generics.toArray(new JavaType[generics.size()])) .build(); } }, INLINEABLE {
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(); } },
public JavaType apply(JavaType item) { List<JavaType> generics = new ArrayList<JavaType>(); for (JavaType generic : item.getGenericTypes()) { generics.add(generic); } generics.add(Constants.Q); return new JavaTypeBuilder(item) .withClassName(item.getClassName() + "Fluent") .withGenericTypes(generics.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(); }
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(); } } }
@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)}); } } };
@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 {
@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(); }
@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 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(); } } };
interfaces.add(alternative.getType()); terminatingTypes.addAll(getTerminatingTypes(alternative.getType())); for (JavaType candidate : alternative.getType().getGenericTypes()) { genericTypes.addAll(getGenericReferences(candidate)); interfaces.add(fallback.getType()); terminatingTypes.addAll(getTerminatingTypes(fallback.getType())); for (JavaType candidate : fallback.getType().getGenericTypes()) { genericTypes.addAll(getGenericReferences(candidate));
@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 JavaMethod apply(JavaProperty property) { JavaType mapType = property.getType(); JavaType keyType = mapType.getGenericTypes()[0]; JavaType valueType = mapType.getGenericTypes()[1]; JavaProperty keyProperty = new JavaPropertyBuilder().withName("key").withType(keyType).build(); JavaProperty valueProperty = new JavaPropertyBuilder().withName("value").withType(valueType).build(); String methodName = "addTo" + property.getNameCapitalized(); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withName(methodName) .withReturnType(T) .withArguments(new JavaProperty[]{keyProperty, valueProperty}) .addToAttributes(BODY, "if(key != null && value != null) {this." + property.getName() + ".put(key, value);} return (T)this;") .build(); } }, REMOVE_FROM_MAP {
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(); }
@Override public JavaMethod apply(JavaProperty property) { JavaType mapType = property.getType(); JavaType keyType = mapType.getGenericTypes()[0]; JavaProperty keyProperty = new JavaPropertyBuilder().withName("key").withType(keyType).build(); String methodName = "removeFrom" + property.getNameCapitalized(); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withName(methodName) .withReturnType(T) .withArguments(new JavaProperty[]{keyProperty}) .addToAttributes(BODY, "if(key != null) {this." + property.getName() + ".remove(key);} return (T)this;") .build(); } }, WITH_NEW_NESTED {
.withPackageName(builderPackage) .withClassName(VISITOR.getClassName()) .withGenericTypes(VISITOR.getGenericTypes()) .and() .addNewMethod() .withKind(JavaKind.INTERFACE) .withClassName(BUILDER.getClassName()) .withGenericTypes(BUILDER.getGenericTypes()) .and() .addNewMethod() .withPackageName(builderPackage) .withClassName(FLUENT.getClassName()) .withGenericTypes(FLUENT.getGenericTypes()) .and() .build(); .withPackageName(builderPackage) .withClassName(BASE_FLUENT.getClassName()) .withGenericTypes(BASE_FLUENT.getGenericTypes()) .addToInterfaces(fluentInterface.getType()) .addToInterfaces(typeGenericOf(visitableInterface.getType(),T)) .withPackageName(builderPackage) .withClassName(NESTED.getClassName()) .withGenericTypes(NESTED.getGenericTypes()) .and() .addNewMethod()