Esempio n. 1
0
 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();
 }
Esempio n. 2
0
  public BuilderContext(
      Elements elements,
      Boolean generateBuilderPackage,
      String builderPackage,
      Inline... inlineables) {
    this.elements = elements;
    this.generateBuilderPackage = generateBuilderPackage;
    this.builderPackage = builderPackage;
    this.inlineables = inlineables;

    stringJavaTypeFunction = new ToBuildableJavaType(elements);
    variableElementJavaPropertyFunction = new ToBuildableJavaProperty(stringJavaTypeFunction);
    executableElementToJavaMethod =
        new ExecutableElementToJavaMethod(
            stringJavaTypeFunction, variableElementJavaPropertyFunction);
    typeElementToJavaClazz =
        new TypeElementToJavaClazz(
            elements,
            stringJavaTypeFunction,
            executableElementToJavaMethod,
            variableElementJavaPropertyFunction);

    repository = new BuildableRepository();

    visitorInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(VISITOR.getClassName())
            .withGenericTypes(VISITOR.getGenericTypes())
            .and()
            .addNewMethod()
            .addToModifiers(Modifier.PUBLIC)
            .withReturnType(VOID)
            .withName("visit")
            .addNewArgument()
            .withName("item")
            .withType(V)
            .endArgument()
            .and()
            .build();

    JavaType visitorBase = unwrapGeneric(visitorInterface.getType());

    visitableInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(VISITABLE.getClassName())
            .withGenericTypes(new JavaType[] {V})
            .and()
            .addNewMethod()
            .addToModifiers(Modifier.PUBLIC)
            .withReturnType(V)
            .withName("accept")
            .addNewArgument()
            .withName("visitor")
            .withType(visitorBase)
            .endArgument()
            .and()
            .build();

    JavaType visitableBase = unwrapGeneric(visitableInterface.getType());

    builderInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withPackageName(builderPackage)
            .withKind(JavaKind.INTERFACE)
            .withClassName(BUILDER.getClassName())
            .withGenericTypes(BUILDER.getGenericTypes())
            .and()
            .addNewMethod()
            .withReturnType(T)
            .withName("build")
            .and()
            .build();

    fluentInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(FLUENT.getClassName())
            .withGenericTypes(FLUENT.getGenericTypes())
            .and()
            .build();

    baseFluentClass =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.CLASS)
            .withPackageName(builderPackage)
            .withClassName(BASE_FLUENT.getClassName())
            .withGenericTypes(BASE_FLUENT.getGenericTypes())
            .addToInterfaces(fluentInterface.getType())
            .addToInterfaces(typeGenericOf(visitableInterface.getType(), T))
            .and()
            .addNewMethod()
            .addToTypeParameters(T)
            .addToModifiers(Modifier.PUBLIC)
            .withName("build")
            .withReturnType(typeGenericOf(ARRAY_LIST, T))
            .addNewArgument()
            .withType(
                typeGenericOf(LIST, typeExtends(Q, typeGenericOf(builderInterface.getType(), T))))
            .withName("list")
            .endArgument()
            .addToAttributes(BODY, loadResourceQuietly(BUILD_LIST_SNIPPET))
            .and()
            .addNewMethod()
            .addToTypeParameters(T)
            .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()
            .addToAttributes(BODY, loadResourceQuietly(BUILD_SET_SNIPPET))
            .and()
            .addNewMethod()
            .addToTypeParameters(T)
            .addToModifiers(Modifier.PUBLIC)
            .withName("aggregate")
            .withReturnType(typeGenericOf(ARRAY_LIST, T))
            .addNewArgument()
            .withType(typeGenericOf(LIST, typeExtends(Q, T)))
            .withName("...lists")
            .endArgument()
            .addToAttributes(BODY, loadResourceQuietly(AGGREGATE_LIST_SNIPPET))
            .and()
            .addNewMethod()
            .addToTypeParameters(T)
            .addToModifiers(Modifier.PUBLIC)
            .withName("aggregate")
            .withReturnType(typeGenericOf(LINKED_HASH_SET, T))
            .addNewArgument()
            .withType(typeGenericOf(SET, typeExtends(Q, T)))
            .withName("...sets")
            .endArgument()
            .addToAttributes(BODY, loadResourceQuietly(AGGREGATE_SET_SNIPPET))
            .and()
            .addNewMethod()
            .addToModifiers(Modifier.PUBLIC)
            .withName("accept")
            .withReturnType(T)
            .addNewArgument()
            .withType(visitorBase)
            .withName("visitor")
            .endArgument()
            .addToAttributes(BODY, loadResourceQuietly(ACCEPT_VISITOR_SNIPPET))
            .and()
            .addNewField()
            .addToModifiers(Modifier.PUBLIC)
            .addToModifiers(Modifier.FINAL)
            .withName("_visitables")
            .withType(
                new JavaTypeBuilder(typeGenericOf(LIST, visitableBase))
                    .withDefaultImplementation(typeGenericOf(ARRAY_LIST, visitableBase))
                    .build())
            .and()
            .build();

    nestedInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(NESTED.getClassName())
            .withGenericTypes(NESTED.getGenericTypes())
            .and()
            .addNewMethod()
            .withReturnType(N)
            .withName("and")
            .and()
            .build();

    editableInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(EDITABLE.getClassName())
            .withGenericTypes(EDITABLE.getGenericTypes())
            .and()
            .addNewMethod()
            .withReturnType(T)
            .withName("edit")
            .and()
            .build();

    visitableBuilderInterface =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(VISITABLE_BUILDER.getClassName())
            .addToInterfaces(visitableInterface.getType())
            .addToInterfaces(builderInterface.getType())
            .withGenericTypes(VISITABLE_BUILDER.getGenericTypes())
            .and()
            .build();

    inlineableBase =
        new JavaClazzBuilder()
            .withNewType()
            .withKind(JavaKind.INTERFACE)
            .withPackageName(builderPackage)
            .withClassName(INLINEABLE.getClassName())
            .withGenericTypes(INLINEABLE.getGenericTypes())
            .and()
            .addNewMethod()
            .withReturnType(T)
            .withName("inline")
            .and()
            .build();
  }