Interface ClassFileBuilder<E extends ClassFileElement, B extends ClassFileBuilder<E,B>>

Type Parameters:
E - the member element type
B - the self type of this builder
All Superinterfaces:
Consumer<E>
All Known Subinterfaces:
ClassBuilder, CodeBuilder, CodeBuilder.BlockCodeBuilder, FieldBuilder, MethodBuilder
public sealed interface ClassFileBuilder<E extends ClassFileElement, B extends ClassFileBuilder<E,B>> extends Consumer<E> permits ClassBuilder, FieldBuilder, MethodBuilder, CodeBuilder
A builder for a CompoundElement, which accepts the member elements to be integrated into the built structure. Builders are usually passed as an argument to Consumer handlers, such as in ClassFile.build(ClassDesc, Consumer). The handlers should deliver elements to a builder similar to how a CompoundElement traverses its member elements.

The basic way a builder accepts elements is through with(E), which supports call chaining. Concrete subtypes of builders usually define extra methods to define elements directly to the builder, such as ClassBuilder.withFlags(int) or CodeBuilder.aload(int).

Whether a member element can appear multiple times in a compound structure affects the behavior of the element in ClassFileBuilders. If an element can appear at most once but multiple instances are supplied to a ClassFileBuilder, the last supplied instance appears on the built structure. If an element appears exactly once but no instance is supplied, an unspecified default value element may be used in that structure.

Due to restrictions of the class file format, certain member elements that can be modeled by the API cannot be represented in the built structure under specific circumstances. Passing such elements to the builder causes IllegalArgumentException. Some ClassFile.Options control whether such elements should be altered or dropped to produce valid class files.

Sealed Class Hierarchy Graph:
Sealed class hierarchy graph for ClassFileBuilderSealed class hierarchy graph for ClassFileBuilder
Since:
24
See Also:

  • Method Summary

    Modifier and Type
    Method
    Description
    default void
    accept(E e)
    Integrates the member element into the structure being built.
    ConstantPoolBuilder
    constantPool()
    Returns the constant pool builder associated with this builder.
    default B
    transform(CompoundElement<E> model, ClassFileTransform<?,E,B> transform)
    Applies a transform to a compound structure, directing results to this builder.
    B
    with(E e)
    Integrates the member element into the structure being built.

    Methods declared in interface Consumer

    andThen

  • Method Details

    • accept

      default void accept(E e)
      Integrates the member element into the structure being built.
      Specified by:
      accept in interface Consumer<E extends ClassFileElement>
      API Note:
      This method exists to implement Consumer; users can use with(E) for call chaining.
      Parameters:
      e - the member element
      Throws:
      IllegalArgumentException - if the member element cannot be represented in the class file format

    • with

      B with(E e)
      Integrates the member element into the structure being built.
      Parameters:
      e - the member element
      Returns:
      this builder
      Throws:
      IllegalArgumentException - if the member element cannot be represented in the class file format

    • constantPool

      ConstantPoolBuilder constantPool()
      Returns the constant pool builder associated with this builder.
      Returns:
      the constant pool builder associated with this builder

    • transform

      default B transform(CompoundElement<E> model, ClassFileTransform<?,E,B> transform)
      Applies a transform to a compound structure, directing results to this builder.

      The transform will receive each element of the compound structure, as well as this builder for building the structure. The transform is free to preserve, remove, or replace elements as it sees fit.

      A builder can run multiple transforms against different compound structures, integrating member elements of different origins.

      API Note:
      Many subinterfaces have methods like ClassBuilder.transformMethod(MethodModel, MethodTransform) or MethodBuilder.transformCode(CodeModel, CodeTransform). However, calling them is fundamentally different from calling this method: those methods call the transform on the child builders instead of on itself. For example, classBuilder.transformMethod calls methodBuilder.transform with a new method builder instead of calling classBuilder.transform on itself.
      Parameters:
      model - the structure to transform
      transform - the transform to apply
      Returns:
      this builder
      See Also: