How to use

typeGenericOf

method

in

io.sundr.codegen.utils.TypeUtils

public JavaType apply(JavaType item) {
  return typeGenericOf(Constants.ARRAY_LIST, item);
}

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

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

builderType = typeGenericOf(toAdd.getType(), builderType);
  builderType = typeGenericOf(descendant.getType(), builderType);

String builderName = "build" + property.getNameCapitalized();
TypeRef unwrapped = TypeAs.combine(TypeAs.UNWRAP_COLLECTION_OF, TypeAs.UNWRAP_ARRAY_OF).apply(property.getTypeRef());
TypeDef predicate = typeGenericOf(BuilderContextManager.getContext().getPredicateClass(), T);

.withGenericTypes(BASE_FLUENT.getGenericTypes())
.addToInterfaces(fluentInterface.getType())
.addToInterfaces(typeGenericOf(visitableInterface.getType(),T))
.and()
.addNewMethod()
  .addToModifiers(Modifier.PUBLIC)
  .withName("build")
  .withReturnType(typeGenericOf(ARRAY_LIST, T))
  .addNewArgument()
    .withType(typeGenericOf(LIST, typeExtends(Q, typeGenericOf(builderInterface.getType(), T))))
    .withName("list")
  .endArgument()
  .addToModifiers(Modifier.PUBLIC)
    .withName("build")
    .withReturnType(typeGenericOf(LINKED_HASH_SET, T))
    .addNewArgument()
      .withType(typeGenericOf(LINKED_HASH_SET, typeExtends(Q, typeGenericOf(builderInterface.getType(), T))))
      .withName("set")
    .endArgument()
  .addToModifiers(Modifier.PUBLIC)
  .withName("aggregate")
  .withReturnType(typeGenericOf(ARRAY_LIST, T))
  .addNewArgument()
    .withType(typeGenericOf(LIST, typeExtends(Q, T)))
    .withName("...lists")
  .endArgument()

TypeRef unwrapped = TypeAs.combine(TypeAs.UNWRAP_COLLECTION_OF, TypeAs.UNWRAP_ARRAY_OF, TypeAs.UNWRAP_OPTIONAL_OF).apply(property.getTypeRef());
TypeDef predicate = typeGenericOf(BuilderContextManager.getContext().getPredicateClass(), T);
String prefix = Getter.prefix(property);
String getterName = Getter.name(property);

TypeDef predicate = typeGenericOf(BuilderContextManager.getContext().getPredicateClass(), T);

.withType(typeGenericOf(BuilderContextManager.getContext().getVisitorInterface().getType(), item.getType()))
.withName("visitor")
.addToModifiers(Modifier.PRIVATE)