@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) { 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(); } };
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(); } },
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) { 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 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) .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(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); } 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(JavaProperty property) { return new JavaTypeBuilder() .withClassName(captializeFirst(property.getName() + "Nested")) .withGenericTypes(new JavaType[]{N}) .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(); }
@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(); }
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(); }
@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 JavaMethod apply(JavaProperty property) { JavaType nestedType = PropertyAs.NESTED_TYPE.apply(property); //We need to repackage because we are nesting under this class. JavaType rewraped = new JavaTypeBuilder(nestedType).withGenericTypes(new JavaType[]{T}).build(); String prefix = "edit"; String methodNameBase = captializeFirst(property.getName()); String methodName = prefix + methodNameBase; return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(rewraped) .withName(methodName) .addToAttributes(BODY, "return withNew" + methodNameBase + "Like(get" + methodNameBase + "());") .build(); } }, AND {
@Override public JavaMethod apply(JavaProperty property) { //We need to repackage because we are nesting under this class. JavaType nestedType = PropertyAs.NESTED_TYPE.apply(property); JavaType rewraped = new JavaTypeBuilder(nestedType).withGenericTypes(new JavaType[]{T}).build(); String prefix = property.getType().isCollection() ? "addNew" : "withNew"; String methodName = prefix + captializeFirst(property.getType().isCollection() ? singularize(property.getName()) : property.getName()); return new JavaMethodBuilder() .addToModifiers(Modifier.PUBLIC) .withReturnType(rewraped) .withName(methodName) .addToAttributes(BODY, "return new " + rewraped.getSimpleName() + "();") .build(); } }, WITH_NEW_LIKE_NESTED {
@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(); }