# 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 `ClassFileBuilder`s. 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.Option`s control whether such elements should be altered or dropped to produce valid `class` files.

Sealed Class Hierarchy Graph:
Since:
  24
See Also:
  - `CompoundElement`
  - `ClassFileTransform`

## 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`
Modifier and Type
Method
Description
`default Consumer<E>`
`andThen(Consumer<? super E> after)`
Returns a composed `Consumer` that performs, in sequence, this operation followed by the `after` operation.

## 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:
  - `ClassFileTransform`