U
- A loaded type that the built type is guaranteed to be a subclass of.public abstract static class DynamicType.Builder.AbstractBase.Delegator<U> extends DynamicType.Builder.AbstractBase<U>
DynamicType.Builder.AbstractBase.Adapter<U>, DynamicType.Builder.AbstractBase.Delegator<U>, DynamicType.Builder.AbstractBase.UsingTypeWriter<U>
DynamicType.Builder.AbstractBase<S>, DynamicType.Builder.FieldDefinition<S>, DynamicType.Builder.InnerTypeDefinition<S>, DynamicType.Builder.MethodDefinition<S>, DynamicType.Builder.RecordComponentDefinition<S>, DynamicType.Builder.TypeVariableDefinition<S>
Constructor and Description |
---|
Delegator() |
Modifier and Type | Method and Description |
---|---|
DynamicType.Builder<U> |
annotateType(Collection<? extends AnnotationDescription> annotations)
Annotates the instrumented type with the supplied annotations.
|
DynamicType.Builder<U> |
attribute(TypeAttributeAppender typeAttributeAppender)
Applies the given type attribute appender onto the instrumented type.
|
DynamicType.Builder<U> |
declaredTypes(Collection<? extends TypeDescription> types)
Defines this type as an the outer type of the supplied types.
|
DynamicType.Builder.RecordComponentDefinition.Optional<U> |
define(RecordComponentDescription recordComponentDescription)
Defines a new record component.
|
DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial<U> |
defineConstructor(int modifiers)
Defines the specified constructor to be declared by the instrumented type.
|
DynamicType.Builder.FieldDefinition.Optional.Valuable<U> |
defineField(String name,
TypeDefinition type,
int modifiers)
Defines the specified field as a field of the built dynamic type.
|
DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial<U> |
defineMethod(String name,
TypeDefinition returnType,
int modifiers)
Defines the specified method to be declared by the instrumented type.
|
DynamicType.Builder.RecordComponentDefinition.Optional<U> |
defineRecordComponent(String name,
TypeDefinition type)
Defines a new record component.
|
DynamicType.Builder.FieldDefinition.Valuable<U> |
field(LatentMatcher<? super FieldDescription> matcher)
Matches a field that is already declared by the instrumented type.
|
DynamicType.Builder<U> |
ignoreAlso(ElementMatcher<? super MethodDescription> ignoredMethods)
Specifies to exclude any method that is matched by the supplied matcher from instrumentation.
|
DynamicType.Builder<U> |
ignoreAlso(LatentMatcher<? super MethodDescription> ignoredMethods)
Specifies to exclude any method that is matched by the supplied matcher from instrumentation.
|
DynamicType.Builder.MethodDefinition.ImplementationDefinition.Optional<U> |
implement(Collection<? extends TypeDefinition> interfaceTypes)
Implements the supplied interfaces for the instrumented type.
|
DynamicType.Builder<U> |
initializer(ByteCodeAppender byteCodeAppender)
Executes the supplied byte code appender within the beginning of the instrumented type's type initializer.
|
DynamicType.Builder<U> |
initializer(LoadedTypeInitializer loadedTypeInitializer)
Executes the supplied loaded type initializer when loading the created instrumented type.
|
DynamicType.Builder.InnerTypeDefinition<U> |
innerTypeOf(MethodDescription.InDefinedShape methodDescription)
Defines this type as an inner type that was declared within the supplied method or constructor.
|
DynamicType.Builder.InnerTypeDefinition.ForType<U> |
innerTypeOf(TypeDescription type)
Defines this type as an inner type of the supplied type.
|
DynamicType.Builder.MethodDefinition.ImplementationDefinition<U> |
invokable(LatentMatcher<? super MethodDescription> matcher)
Matches a method or constructor that is already declared or inherited by the instrumented type.
|
DynamicType.Unloaded<U> |
make()
Creates the dynamic type this builder represents.
|
DynamicType.Unloaded<U> |
make(TypePool typePool)
Creates the dynamic type this builder represents.
|
DynamicType.Unloaded<U> |
make(TypeResolutionStrategy typeResolutionStrategy)
Creates the dynamic type this builder represents.
|
DynamicType.Unloaded<U> |
make(TypeResolutionStrategy typeResolutionStrategy,
TypePool typePool)
Creates the dynamic type this builder represents.
|
protected abstract DynamicType.Builder<U> |
materialize()
Creates a new builder that realizes the current state of the builder.
|
DynamicType.Builder<U> |
merge(Collection<? extends ModifierContributor.ForType> modifierContributors)
Merges the supplied modifier contributors with the modifiers of the instrumented type and defines them as the instrumented
type's new modifiers.
|
DynamicType.Builder<U> |
modifiers(int modifiers)
Defines the supplied modifiers as the modifiers of the instrumented type.
|
DynamicType.Builder<U> |
name(String name)
Names the dynamic type by the supplied name.
|
DynamicType.Builder<U> |
nestHost(TypeDescription type)
Defines this type as a nest member of the supplied type as a nest host.
|
DynamicType.Builder<U> |
nestMembers(Collection<? extends TypeDescription> types)
Defines this type as a nest host for the supplied types.
|
DynamicType.Builder<U> |
permittedSubclass(Collection<? extends TypeDescription> types)
Defines this type to allow the supplied permitted subclasses additionally to any prior permitted subclasses.
|
DynamicType.Builder.RecordComponentDefinition<U> |
recordComponent(ElementMatcher<? super RecordComponentDescription> matcher)
Matches a record component that is already declared by the instrumented type.
|
DynamicType.Builder.RecordComponentDefinition<U> |
recordComponent(LatentMatcher<? super RecordComponentDescription> matcher)
Matches a record component that is already declared by the instrumented type.
|
DynamicType.Builder<U> |
require(Collection<DynamicType> auxiliaryTypes)
Explicitly requires other dynamic types for the creation of this type.
|
DynamicType.Builder<U> |
suffix(String suffix)
Adds a suffix to the current type name without changing the type's package.
|
DynamicType.Builder<U> |
topLevelType()
Defines this type as a top-level type that is not declared by another type or enclosed by another member.
|
TypeDescription |
toTypeDescription()
Returns a
TypeDescription for the currently built type. |
DynamicType.Builder<U> |
transform(ElementMatcher<? super TypeDescription.Generic> matcher,
Transformer<TypeVariableToken> transformer)
Transforms any type variable that is defined by this type if it is matched by the supplied matcher.
|
DynamicType.Builder.TypeVariableDefinition<U> |
typeVariable(String symbol,
Collection<? extends TypeDefinition> bounds)
Defines the supplied type variable with the given bound as a type variable of the instrumented type.
|
DynamicType.Builder<U> |
unsealed()
Unseales this type.
|
DynamicType.Builder<U> |
visit(AsmVisitorWrapper asmVisitorWrapper)
Applies the supplied
AsmVisitorWrapper onto the ClassVisitor during building a dynamic type. |
ContextClassVisitor |
wrap(ClassVisitor classVisitor,
int writerFlags,
int readerFlags)
Wraps a class visitor with the configuration that is represented by this dynamic type builder, using a
default
TypePool . |
ContextClassVisitor |
wrap(ClassVisitor classVisitor,
TypePool typePool,
int writerFlags,
int readerFlags)
Wraps a class visitor with the configuration that is represented by this dynamic type builder.
|
annotateType, annotateType, annotateType, constructor, declaredTypes, declaredTypes, declaredTypes, define, define, define, define, define, defineConstructor, defineConstructor, defineField, defineField, defineField, defineField, defineField, defineMethod, defineMethod, defineMethod, defineMethod, defineMethod, defineProperty, defineProperty, defineProperty, defineProperty, defineRecordComponent, field, implement, implement, implement, innerTypeOf, innerTypeOf, innerTypeOf, invokable, merge, method, modifiers, modifiers, nestHost, nestMembers, nestMembers, nestMembers, noNestMate, permittedSubclass, permittedSubclass, permittedSubclass, require, require, require, serialVersionUid, typeVariable, typeVariable, typeVariable, typeVariable, withHashCodeEquals, withToString, wrap, wrap
public DynamicType.Builder<U> visit(AsmVisitorWrapper asmVisitorWrapper)
AsmVisitorWrapper
onto the ClassVisitor
during building a dynamic type.
Using an ASM visitor, it is possible to manipulate byte code directly. Byte Buddy does not validate directly created byte code
and it remains the responsibility of the visitor's implementor to generate legal byte code. If several ASM visitor wrappers
are registered, they are applied on top of another in their registration order.asmVisitorWrapper
- The ASM visitor wrapper to apply duringpublic DynamicType.Builder<U> initializer(LoadedTypeInitializer loadedTypeInitializer)
loadedTypeInitializer
- The loaded type initializer to execute upon loading the instrumented type.public DynamicType.Builder<U> annotateType(Collection<? extends AnnotationDescription> annotations)
annotations
- The annotations to add to the instrumented type.public DynamicType.Builder<U> attribute(TypeAttributeAppender typeAttributeAppender)
Annotation
s.typeAttributeAppender
- The type attribute appender to apply.public DynamicType.Builder<U> modifiers(int modifiers)
modifiers
- The modifiers of the instrumented type.public DynamicType.Builder<U> merge(Collection<? extends ModifierContributor.ForType> modifierContributors)
modifierContributors
- The modifiers of the instrumented type.public DynamicType.Builder<U> suffix(String suffix)
suffix
- The suffix to append to the current type name.public DynamicType.Builder<U> name(String name)
foo.Bar
). A type's package determines what other types are visible to the instrumented type and what methods
can be overridden or be represented in method signatures or as field types.name
- The fully qualified name of the generated class in a binary format.public DynamicType.Builder<U> topLevelType()
Defines this type as a top-level type that is not declared by another type or enclosed by another member.
Important: Changing the declaration hierarchy of a type has no influence on the nest mate hierarchy.
Warning: By changing this type's declaration, any other type will not change its declaration of enclosing members or declared types about any nesting of a declaration. It is the responsibility of the user of this API to keep such declarations consistent among the definitions of connected types.
public DynamicType.Builder.InnerTypeDefinition.ForType<U> innerTypeOf(TypeDescription type)
Defines this type as an inner type of the supplied type. Without any additional configuration, the type declaration is defined as a local type.
Important: Changing the declaration hierarchy of a type has no influence on the nest mate hierarchy.
Warning: By changing this type's declaration, any other type will not change its declaration of enclosing members or declared types about any nesting of a declaration. It is the responsibility of the user of this API to keep such declarations consistent among the definitions of connected types.
type
- The type to declare as the built type's outer type.public DynamicType.Builder.InnerTypeDefinition<U> innerTypeOf(MethodDescription.InDefinedShape methodDescription)
Defines this type as an inner type that was declared within the supplied method or constructor. Without any additional configuration, the type declaration is defined as a local type.
Important: Changing the declaration hierarchy of a type has no influence on the nest mate hierarchy.
Warning: By changing this type's declaration, any other type will not change its declaration of enclosing members or declared types about any nesting of a declaration. It is the responsibility of the user of this API to keep such declarations consistent among the definitions of connected types.
methodDescription
- The method or constructor to declare as the built type's declaring method.public DynamicType.Builder<U> declaredTypes(Collection<? extends TypeDescription> types)
Defines this type as an the outer type of the supplied types. Using this method, it is possible to add inner type declarations for anonymous or local types which are not normally exposed by type descriptions. Doing so, it is however possible to indicate to Byte Buddy that the required attributes for such an inner type declaration should be added to a class file.
Important: Changing the declaration hierarchy of a type has no influence on the nest mate hierarchy.
Warning: By changing this type's declaration, any other type will not change its declaration of enclosing members or declared types about any nesting of a declaration. It is the responsibility of the user of this API to keep such declarations consistent among the definitions of connected types.
types
- The types being declared.public DynamicType.Builder<U> nestHost(TypeDescription type)
Defines this type as a nest member of the supplied type as a nest host.
Important: Changing the nest mate hierarchy of a type has no influence on the declaration hierarchy.
Warning: Changing nest mate hierarchies always requires changing a member and its host or a host and all its members. Otherwise, the runtime will not accept further nest mates. It is the responsibility of the user of this API to keep such declarations consistent among the definitions of connected types.
type
- The nest host.public DynamicType.Builder<U> nestMembers(Collection<? extends TypeDescription> types)
Defines this type as a nest host for the supplied types.
Important: Changing the nest mate hierarchy of a type has no influence on the declaration hierarchy.
Warning: Changing nest mate hierarchies always requires changing a member and its host or a host and all its members. Otherwise, the runtime will not accept further nest mates. It is the responsibility of the user of this API to keep such declarations consistent among the definitions of connected types.
types
- The nest members.public DynamicType.Builder<U> permittedSubclass(Collection<? extends TypeDescription> types)
types
- The permitted subclasses.public DynamicType.Builder<U> unsealed()
public DynamicType.Builder.MethodDefinition.ImplementationDefinition.Optional<U> implement(Collection<? extends TypeDefinition> interfaceTypes)
Implements the supplied interfaces for the instrumented type. Optionally, it is possible to define the methods that are defined by the interfaces or the interfaces' super interfaces. This excludes methods that are explicitly ignored.
Note: This methods implements the supplied types as is, i.e. any TypeDescription
values are
implemented as raw types if they declare type variables or an owner type.
interfaceTypes
- The interface types to implement.public DynamicType.Builder<U> initializer(ByteCodeAppender byteCodeAppender)
Executes the supplied byte code appender within the beginning of the instrumented type's type initializer. The supplied byte code appender must not return from the method. If several byte code appenders are supplied, they are executed within their application order.
This method should only be used for preparing an instrumented type with a specific configuration. Normally,
a byte code appender is applied via Byte Buddy's standard API by invoking DynamicType.Builder.invokable(ElementMatcher)
using the ElementMatchers.isTypeInitializer()
matcher.
byteCodeAppender
- The byte code appender to execute within the instrumented type's type initializer.public DynamicType.Builder<U> ignoreAlso(ElementMatcher<? super MethodDescription> ignoredMethods)
Specifies to exclude any method that is matched by the supplied matcher from instrumentation. Previously supplied matchers remain valid after supplying a new matcher, i.e. any method that is matched by a previously supplied matcher is always ignored.
When ignoring a type, previously registered matchers are applied before this matcher. If a previous matcher indicates that a type is to be ignored, this matcher is no longer executed.
ignoreAlso
in interface DynamicType.Builder<U>
ignoreAlso
in class DynamicType.Builder.AbstractBase<U>
ignoredMethods
- The matcher for determining what methods to exclude from instrumentation.public DynamicType.Builder<U> ignoreAlso(LatentMatcher<? super MethodDescription> ignoredMethods)
Specifies to exclude any method that is matched by the supplied matcher from instrumentation. Previously supplied matchers
remain valid after supplying a new matcher, i.e. any method that is matched by a previously supplied matcher is always ignored.
Using a latent matcher gives opportunity to resolve an ElementMatcher
based on the instrumented type before applying the
matcher.
When ignoring a type, previously registered matchers are applied before this matcher. If a previous matcher indicates that a type is to be ignored, this matcher is no longer executed.
ignoredMethods
- The matcher for determining what methods to exclude from instrumentation.public DynamicType.Builder.TypeVariableDefinition<U> typeVariable(String symbol, Collection<? extends TypeDefinition> bounds)
symbol
- The type variable's symbol.bounds
- The type variable's upper bounds. Can also be TargetType
if the bound type
should be equal to the currently instrumented type.public DynamicType.Builder<U> transform(ElementMatcher<? super TypeDescription.Generic> matcher, Transformer<TypeVariableToken> transformer)
matcher
- The matcher to decide what type variables to transform.transformer
- The transformer to apply to the matched type variables.public DynamicType.Builder.FieldDefinition.Optional.Valuable<U> defineField(String name, TypeDefinition type, int modifiers)
name
- The name of the field.type
- The type of the field. Can also be TargetType
if the field type
should be equal to the currently instrumented type.modifiers
- The modifiers of the field.public DynamicType.Builder.FieldDefinition.Valuable<U> field(LatentMatcher<? super FieldDescription> matcher)
Matches a field that is already declared by the instrumented type. This gives opportunity to change that field's
default value, annotations or custom attributes. Using a latent matcher gives opportunity to resolve an
ElementMatcher
based on the instrumented type before applying the matcher.
When a type is redefined or rebased, any annotations that the field declared previously is preserved
as it is if Byte Buddy is configured to retain such annotations by
AnnotationRetention.ENABLED
. If any existing annotations should be
altered, annotation retention must be disabled.
If a field is already matched by a previously specified field matcher, the new field definition gets precedence over the previous definition, i.e. the previous field definition is no longer applied.
matcher
- The matcher that determines what declared fields are affected by the subsequent specification.public DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial<U> defineMethod(String name, TypeDefinition returnType, int modifiers)
name
- The name of the method.returnType
- The method's return type. Can also be TargetType
if the return type
should be equal to the currently instrumented type.modifiers
- The method's modifiers.public DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial<U> defineConstructor(int modifiers)
modifiers
- The constructor's modifiers.public DynamicType.Builder.MethodDefinition.ImplementationDefinition<U> invokable(LatentMatcher<? super MethodDescription> matcher)
Matches a method or constructor that is already declared or inherited by the instrumented type. This gives
opportunity to change or to override that method's or constructor's implementation, default value, annotations
or custom attributes. It is also possible to make a method abstract. Using a latent matcher gives opportunity
to resolve an ElementMatcher
based on the instrumented type before applying the matcher.
When a type is redefined or rebased, any annotations that the method or constructor declared previously is preserved
as it is if Byte Buddy is configured to retain such annotations by
AnnotationRetention.ENABLED
. If any existing annotations should be
altered, annotation retention must be disabled.
If a method or constructor is already matched by a previously specified matcher, the new definition gets precedence over the previous definition, i.e. the previous definition is no longer applied.
Note that the specified definition does never apply for methods that are explicitly ignored.
Important: It is possible to instrument the dynamic type's initializer. Depending on the used TypeResolutionStrategy
,
the type initializer might be run before Byte Buddy could apply any LoadedTypeInitializer
s which are
responsible for preparing the instrumented type prior to the initializer's execution. For preparing the type prior to
executing the initializer, an TypeResolutionStrategy.Active
resolver must be chosen.
matcher
- The matcher that determines what declared methods or constructors are affected by the subsequent specification.public DynamicType.Builder<U> require(Collection<DynamicType> auxiliaryTypes)
auxiliaryTypes
- The required dynamic types.public DynamicType.Builder.RecordComponentDefinition.Optional<U> defineRecordComponent(String name, TypeDefinition type)
ByteBuddy.makeRecord()
is used.name
- The record component's name.type
- The record component's type.public DynamicType.Builder.RecordComponentDefinition.Optional<U> define(RecordComponentDescription recordComponentDescription)
ByteBuddy.makeRecord()
is used.define
in interface DynamicType.Builder<U>
define
in class DynamicType.Builder.AbstractBase<U>
recordComponentDescription
- A description of the record component to immitate.public DynamicType.Builder.RecordComponentDefinition<U> recordComponent(ElementMatcher<? super RecordComponentDescription> matcher)
Matches a record component that is already declared by the instrumented type. This gives opportunity to change that record component's annotations or custom attributes.
When a type is redefined or rebased, any annotations that the field declared previously is preserved
as it is if Byte Buddy is configured to retain such annotations by
AnnotationRetention.ENABLED
. If any existing annotations should be
altered, annotation retention must be disabled.
If a record component is already matched by a previously specified record component matcher, the new record component definition gets precedence over the previous definition, i.e. the previous record component definition is no longer applied.
recordComponent
in interface DynamicType.Builder<U>
recordComponent
in class DynamicType.Builder.AbstractBase<U>
matcher
- The matcher that determines what declared record components are affected by the subsequent specification.public DynamicType.Builder.RecordComponentDefinition<U> recordComponent(LatentMatcher<? super RecordComponentDescription> matcher)
Matches a record component that is already declared by the instrumented type. This gives opportunity to change that record component's annotations or custom attributes.
When a type is redefined or rebased, any annotations that the field declared previously is preserved
as it is if Byte Buddy is configured to retain such annotations by
AnnotationRetention.ENABLED
. If any existing annotations should be
altered, annotation retention must be disabled.
If a record component is already matched by a previously specified record component matcher, the new record component definition gets precedence over the previous definition, i.e. the previous record component definition is no longer applied.
matcher
- The matcher that determines what declared record components are affected by the subsequent specification.public ContextClassVisitor wrap(ClassVisitor classVisitor, int writerFlags, int readerFlags)
TypePool
. A wrapper might not apply all features that are normally applied by Byte
Buddy, if those features require control of the class loading life cycle. Neither does a wrapper define
auxiliary types. It is therefore recommended to use Implementation.Context.Disabled
.classVisitor
- The class visitor to wrap.writerFlags
- The ASM writer flags to apply.readerFlags
- The ASM reader flags to apply.public ContextClassVisitor wrap(ClassVisitor classVisitor, TypePool typePool, int writerFlags, int readerFlags)
Implementation.Context.Disabled
.classVisitor
- The class visitor to wrap.typePool
- A type pool that is used for computing stack map frames by the underlying class writer, if required.writerFlags
- The ASM writer flags to apply.readerFlags
- The ASM reader flags to apply.public DynamicType.Unloaded<U> make()
Creates the dynamic type this builder represents. If the specified dynamic type is not legal, an IllegalStateException
is thrown.
Other than DynamicType.Builder.make(TypePool)
, this method supplies a context-dependant type pool to the underlying class writer.
Supplying a type pool only makes sense if custom byte code is created by adding a custom AsmVisitorWrapper
where ASM might be
required to compute stack map frames by processing information over any mentioned type's class hierarchy.
The dynamic type is initialized using a TypeResolutionStrategy.Passive
strategy. Using this strategy, no
LoadedTypeInitializer
is run during the execution of the type's initializer such that no Implementation
used for
executing the initializer must rely on such an initializer.
make
in interface DynamicType.Builder<U>
make
in class DynamicType.Builder.AbstractBase<U>
public DynamicType.Unloaded<U> make(TypeResolutionStrategy typeResolutionStrategy)
Creates the dynamic type this builder represents. If the specified dynamic type is not legal, an IllegalStateException
is thrown.
The dynamic type is initialized using a TypeResolutionStrategy.Passive
strategy. Using this strategy, no
LoadedTypeInitializer
is run during the execution of the type's initializer such that no Implementation
used for
executing the initializer must rely on such an initializer.
typeResolutionStrategy
- The type resolution strategy to use for the created type's initialization.public DynamicType.Unloaded<U> make(TypePool typePool)
Creates the dynamic type this builder represents. If the specified dynamic type is not legal, an IllegalStateException
is thrown.
The dynamic type is initialized using a TypeResolutionStrategy.Passive
strategy. Using this strategy, no
LoadedTypeInitializer
is run during the execution of the type's initializer such that no Implementation
used for
executing the initializer must rely on such an initializer.
make
in interface DynamicType.Builder<U>
make
in class DynamicType.Builder.AbstractBase<U>
typePool
- A type pool that is used for computing stack map frames by the underlying class writer, if required.public DynamicType.Unloaded<U> make(TypeResolutionStrategy typeResolutionStrategy, TypePool typePool)
IllegalStateException
is thrown.typeResolutionStrategy
- The type resolution strategy to use for the created type's initialization.typePool
- A type pool that is used for computing stack map frames by the underlying class writer, if required.public TypeDescription toTypeDescription()
TypeDescription
for the currently built type.TypeDescription
for the currently built type.protected abstract DynamicType.Builder<U> materialize()
Copyright © 2014–2023. All rights reserved.