All Classes and Interfaces
Class
Description
An abstract base implementation of a dynamic type builder that alters an existing type.
A build tool plugin that instruments methods to dispatch to methods
java.security.AccessController with equal signature.An wrapper for a method that represents a method of
AccessController which is weaved.A method visitor to implement a weaved method to dispatch to an
java.security.AccessController, if available.Indicates that the annotated method represents a pseudo implementation of
java.security.AccessController
which can be weaved to dispatch to the access controller if this is possible on the current VM and not explicitly
disabled on the current VM via a system property.A byte code appender to create an initializer segment that determines if
the
java.security.AccessController is available.An initializer that always uses the access controller if it is available.
An initializer that uses a property to determine if the access controller should be actually used even if it is available.
An element matcher that validates that a given byte code element is accessible to a given type.
A stack manipulation that adds two numbers on the operand stack.
Advice wrappers copy the code of blueprint methods to be executed before and/or after a matched method.
A method visitor that weaves the advice methods' byte codes.
An advice visitor that applies exit advice.
An advice visitor that captures exceptions by weaving try-catch blocks around user code.
An advice visitor that does not capture exceptions.
An advice visitor that does not apply exit advice.
Assigns an array containing all arguments of the instrumented method to the annotated parameter.
A byte code appender for implementing
Advice.A method visitor that allows for the emulation of a full method visitor invocation circle without delegating initial
and ending visitations to the underlying visitor.
Indicates that the annotated parameter should be mapped to the parameter with index
Advice.Argument.value() of
the instrumented method.An argument handler is responsible for resolving offsets of the local variable array in the context of the applied instrumentation.
A factory for creating an argument handler.
An argument handler that is used for resolving an advice method.
A default implementation for an argument handler for an advice method.
An argument handler for an enter advice method.
An argument handler for an exit advice method.
An argument handler that is used for resolving the instrumented method.
A default implementation of an argument handler for an instrumented method.
An argument handler for an instrumented method that copies all arguments before executing the instrumented method.
A simple argument handler for an instrumented method.
A post processor that uses the return value of an advice method to define values for fields, arguments, the instrumented
method's return value or the exception being thrown.
Indicates that the advice method's return value is to be treated as a scalar value also if it is
of an array type.
A stack manipulation that applies a null-check on the returned value which indicates if an assignment
should be skipped, if discovered.
A dispatcher for skipping a default value.
An exception handler to handle exceptions during assignment.
A factory for wrapping an assignment with an exception handler, if appropriate.
A factory that creates an exception handler for a given exception type.
A non-operational factory that does not produce an exception handler.
A factory to create a
Advice.AssignReturned post processor.A post processor implementation of
Advice.AssignReturned that works on the value of an array.A post processor implementation of
Advice.AssignReturned that uses the returned value as such.A handler for an
Advice.AssignReturned post processor to assign a value that was returned by
advice to a value of the instrumented method.A factory for resolving a handler for a given advice method.
A simple implementation of a
Advice.AssignReturned.Handler.Factory that resolves a given list of Advice.AssignReturned.Handlers.
Assigns the advice method's return value as an array to a number of arguments which are returned as an array where
each element assigns a single value with the same index as the instrumented method's parameter.
A handler for a
Advice.AssignReturned.ToAllArguments annotation.A factory to create a handler for a
Advice.AssignReturned.ToAllArguments annotation.
Assigns the advice method's return value to an argument of the instrumented method of the given index.
A handler for a
Advice.AssignReturned.ToArguments.ToArgument annotation.A factory to create a handler for a
Advice.AssignReturned.ToArguments annotation.Defines a particular assignment for a
Advice.AssignReturned.ToArguments.
Assigns the advice method's return value to a given field.
A handler for a
Advice.AssignReturned.ToFields.ToField annotation.A factory to create a handler for a
Advice.AssignReturned.ToFields annotation.Determines what fields are assigned when using a
Advice.AssignReturned.ToFields annotation.
Assigns the advice method's return value to the instrumented method's return value.
A handler for a
Advice.AssignReturned.ToReturned annotation.A factory to create a handler for a
Advice.AssignReturned.ToReturned annotation.
Assigns the advice method's return value to the
this reference of the instrumented method.A handler for the
Advice.AssignReturned.ToThis annotation.A handler factory for the
Advice.AssignReturned.ToThis annotation which assigns an advice method's return value
to the this reference of a non-static method.
Assigns the advice method's return value to the instrumented method's return value.
A handler for a
Advice.AssignReturned.ToThrown annotation.A factory to create a handler for a
Advice.AssignReturned.ToThrown annotation.Materializes an advice invocation within a delegation.
Invokes an advice method using a dynamic method call.
Invokes an advice method using a static method call.
A dispatcher for implementing advice.
A bound resolution of an advice method.
A dispatcher for an advice method that is being invoked from the instrumented method.
A resolved version of a dispatcher.
A bound advice method that copies the code by first extracting the exception table and later appending the
code of the method without copying any meta data.
An advice method writer for a method enter.
An advice method writer for a method exit.
A resolved dispatcher for implementing method enter advice.
Implementation of an advice that does not expose an enter type.
Implementation of an advice that does expose an enter type.
A resolved dispatcher for implementing method exit advice.
Implementation of exit advice that handles exceptions.
Implementation of exit advice that ignores exceptions.
An implementation for inactive devise that does not write any byte code.
A dispatcher for an advice method that is being inlined into the instrumented method.
A visitor for translating an advice method's byte code for inlining into the instrumented method.
A resolved version of a dispatcher.
A resolved dispatcher for implementing method enter advice.
Implementation of an advice that does not expose an enter type.
Implementation of an advice that does expose an enter type.
A resolved dispatcher for implementing method exit advice.
Implementation of exit advice that handles exceptions.
Implementation of exit advice that ignores exceptions.
A relocation handler is responsible for chaining the usual control flow of an instrumented method.
A bound
Advice.Dispatcher.RelocationHandler.A disabled relocation handler that does never trigger a relocation.
A relocation handler that is triggered if the checked value is an instance of a given type.
A relocation handler that triggers a relocation for a default or non-default value.
A relocator is responsible for triggering a relocation if a relocation handler triggers a relocating condition.
A relocation that unconditionally jumps to a given label.
Represents a resolved dispatcher.
An abstract base implementation of a
Advice.Dispatcher.Resolved dispatcher.Represents a resolved dispatcher for entering a method.
Represents a resolved dispatcher for exiting a method.
A suppression handler for optionally suppressing exceptions.
A bound version of a suppression handler that must not be reused.
A non-operational suppression handler that does not suppress any method.
A suppression handler that suppresses a given throwable type.
An active, bound suppression handler.
A dispatcher that is not yet resolved.
Indicates that the annotated parameter should be mapped to the value that is returned by the advice method that is annotated
by
Advice.OnMethodEnter.An exception handler is responsible for providing byte code for handling an exception thrown from a suppressing advice method.
Default implementations for commonly used exception handlers.
A simple exception handler that returns a fixed stack manipulation.
Indicates that the annotated parameter should be mapped to the value that is returned by the advice method that is annotated
by
Advice.OnMethodExit.
Indicates that the annotated parameter should be mapped to a field in the scope of the instrumented method.
Declares the annotated parameter as a local variable that is created by Byte Buddy for the instrumented method.
A handler for computing the instrumented method's size.
A default implementation for a method size handler.
A method size handler that expects that the original arguments were copied.
A method size handler that expects that the original arguments are retained.
A method size handler for an advice method.
A method size handler for the instrumented method.
A non-operational method size handler.
A marker class that indicates that an advice method does not suppress any
Throwable.Represents an offset mapping for an advice method to an alternative offset.
Represents a factory for creating a
Advice.OffsetMapping for a given parameter for a given annotation.Describes the type of advice being applied.
A factory for an annotation whose use is not permitted.
A simple factory that binds a constant offset mapping.
An offset mapping that maps an array containing all arguments of the instrumented method.
A factory for an offset mapping that maps all arguments values of the instrumented method.
An offset mapping for a given parameter of the instrumented method.
An offset mapping for a specific parameter of the instrumented method.
A factory for a parameter argument of the instrumented method.
An offset mapping for a parameter of the instrumented method with a specific index.
A factory for a mapping of a parameter of the instrumented method.
An offset mapping that provides access to the value that is returned by the enter advice.
A factory for creating a
Advice.OffsetMapping.ForEnterValue offset mapping.An offset mapping that provides access to the value that is returned by the exit advice.
A factory for creating a
Advice.OffsetMapping.ForExitValue offset mapping.An offset mapping for a field.
A binding for an offset mapping that represents a specific field.
A factory that binds a field.
An offset mapping for a field that is resolved from the instrumented type by its name.
A factory for a
Advice.OffsetMapping.ForField.Unresolved offset mapping.An offset mapping for a field with an explicit declaring type.
An offset mapping for a field with an implicit declaring type.
Maps a constant representing the instrumented method.
Maps the declaring type of the instrumented method.
An offset mapping that provides access to a named local variable that is declared by the advice methods via
Advice.Local.A factory for an offset mapping for a local variable that is declared by the advice methods via
Advice.Local.An offset mapping for the
Advice.Origin annotation.A factory for a method origin.
A renderer for an origin pattern element.
A renderer for a constant value.
A renderer for a method descriptor.
A renderer for a method's Java signature in binary form.
A renderer for a method's internal name.
A renderer for a property name.
A renderer for a method's return type in binary form.
A renderer for a method's
Object.toString() representation.A renderer for a method declaring type's binary name.
An offset mapping that provides access to the value that is returned by the instrumented method.
A factory for creating a
Advice.OffsetMapping.ForReturnValue offset mapping.An offset mapping that loads a serialized value.
A factory for loading a deserialized value.
An offset mapping for binding a stack manipulation.
A factory that binds a stack manipulation.
A factory for binding an annotation's property.
A factory for binding the annotated parameter's default value.
Uses dynamic method invocation for binding an annotated parameter to a value.
An offset mapping for a parameter where assignments are fully ignored and that is assigned a boxed version of the instrumented
method's return value or
null if the return type is not primitive or void.An offset mapping that provides access to the
this reference of the instrumented method.A factory for creating a
Advice.OffsetMapping.ForThisReference offset mapping.An offset mapping for accessing a
Throwable of the instrumented method.A factory for accessing an exception that was thrown by the instrumented method.
An offset mapping for a parameter where assignments are fully ignored and that always return the parameter type's default value.
A factory for an offset mapping for an unused value.
Describes the sort of the executed advice.
A target offset of an offset mapping.
An adapter class for a target that only can be read.
A target mapping for an array of all local variables.
A target mapping for a read-only target mapping for an array of local variables.
A target mapping for a writable target mapping for an array of local variables.
A target for an offset mapping that represents a non-operational value.
A read-only target for a default value.
A read-write target for a default value.
A target for an offset mapping that loads a field value.
A read-only mapping for a field value.
A mapping for a writable field.
A target for an offset mapping that represents a read-only stack manipulation.
A constant value that can be written to.
A target for an offset mapping that represents a local variable.
A target for a read-only mapping of a local variable.
A target for a writable mapping of a local variable.
A marker type to be used as an argument for
Advice.OnMethodEnter.skipOn().
Indicates that this method should be inlined before the matched method is invoked.
Indicates that this method should be executed before exiting the instrumented method.
A marker type to be used as an argument for
Advice.OnMethodEnter.skipOn().
Indicates that the annotated parameter should be mapped to a string representation of the instrumented method,
a constant representing the
Class declaring the adviced method or a Method, Constructor
or java.lang.reflect.Executable representing this method.
A post processor for advice methods that is invoked after advice is executed.
A compound post processor.
A factory for creating a
Advice.PostProcessor.A compound factory for a post processor.
A non-operational advice post processor.
Indicates that the annotated parameter should be mapped to the return value of the instrumented method.
A handler for computing and translating stack map frames.
A default implementation of a stack map frame handler for an instrumented method.
Represents the initialization state of a stack value that can either be initialized or uninitialized.
A translation mode that determines how the fixed frames of the instrumented method are written.
A trivial stack map frame handler that applies a trivial translation for the instrumented method's stack map frames.
A stack map frame handler that requires the original arguments of the instrumented method to be preserved in their original form.
A stack map frame handler that expects that an argument copy of the original method arguments was made.
A stack map frame handler that expects that the original argument frames remain preserved throughout the original invocation.
A stack map frame handler for an advice method.
A stack map frame handler for an instrumented method.
A stack map frame handler that can be used within a post processor.
A non-operational stack map frame handler.
Indicates that the annotated parameter should always return a default a boxed version of the instrumented methods return value
(i.e.
Indicates that the annotated parameter should be mapped to the
this reference of the instrumented method.
Indicates that the annotated parameter should be mapped to the
Throwable thrown by the instrumented method or to null
if the method returned regularly.Indicates that the annotated parameter should always return a default value (i.e.
A builder step for creating an
Advice that uses custom mappings of annotations to constant pool values.
An agent builder provides a convenience API for defining a
Java agent.
A circularity lock is responsible for preventing that a
ClassFileLocator is used recursively.A default implementation of a circularity lock.
A circularity lock that holds a global monitor and does not permit concurrent access.
An inactive circularity lock which is always acquirable.
This strategy determines how the provided class file buffer is used.
An implementation of default class file buffer strategy.
The default implementation of an
AgentBuilder.An abstract implementation of an agent builder that delegates all invocation to another instance.
An abstract base implementation of a matchable.
A dispatcher for interacting with the instrumentation API.
A
ClassFileTransformer that implements the enclosing agent builder's
configuration.A factory for creating a
ClassFileTransformer for the current VM.An action to create an implementation of
AgentBuilder.Default.ExecutingTransformer that support Java 9 modules.A factory for a class file transformer on a JVM that supports the
java.lang.Module API to override
the newly added method of the ClassFileTransformer to capture an instrumented class's module.A factory for a
ClassFileTransformer on a VM that does not support the java.lang.Module API.A strategy for determining if a native method name prefix should be used when rebasing methods.
A native method strategy that suffixes method names with a random suffix and disables native method rebasement.
A native method strategy that prefixes method names with a fixed value for supporting rebasing of native methods.
An implementation of a default agent builder that allows for refinement of the redefinition strategy.
A transformation to apply.
A matcher that considers the differential of two transformers' transformations.
A matcher that matches any type that is touched by a transformer without being ignored.
An iterator over a list of transformations that match a raw matcher specification.
A strategy to warm up a
ClassFileTransformer before using it to eagerly load classes and to avoid
circularity errors when classes are loaded during actual transformation for the first time.An enabled warmup strategy.
A dispatcher to interact with a
ClassFileTransformer when the module system is active.A non-operational warmup strategy.
A description strategy is responsible for resolving a
TypeDescription when transforming or retransforming/-defining a type.Default implementations of a
AgentBuilder.DescriptionStrategy.
A description strategy that enforces the loading of any super type of a type description but delegates the actual type description
to another description strategy.
A description strategy that enforces the loading of any super type of a type description but delegates the actual type description
to another description strategy.
A class loading delegate that delegates loading of the super type to another thread.
A class loading action that notifies the class loader's lock after the type was loaded.
A class loading action that simply loads a type.
A class loading delegate that unlocks the circularity lock during class loading.
A fallback strategy allows to reattempt a transformation or a consideration for redefinition/retransformation in case an exception
occurs.
A fallback strategy that discriminates by the type of the
Throwable that triggered a request.A simple fallback strategy that either always reattempts a transformation or never does so.
Describes an
AgentBuilder which was handed a matcher for identifying
types to instrumented in order to supply one or several
AgentBuilder.Transformers.This interface is used to allow for optionally providing several
AgentBuilder.Transformer to applied when a matcher identifies a type
to be instrumented.Allows to specify a type matcher for a type to instrument.
Allows to further specify ignored types.
An initialization strategy which determines the handling of
LoadedTypeInitializers
and the loading of auxiliary types.A dispatcher for changing a class file to adapt a self-initialization strategy.
An initialization strategy that loads auxiliary types before loading the instrumented type.
A non-initializing initialization strategy.
An initialization strategy that adds a code block to an instrumented type's type initializer which
then calls a specific class that is responsible for the explicit initialization.
A dispatcher for a self-initialization strategy.
A type initializer that injects all auxiliary types of the instrumented type.
A form of self-injection where any auxiliary type is loaded eagerly.
A dispatcher for the
AgentBuilder.InitializationStrategy.SelfInjection.Eager strategy.A form of self-injection where any auxiliary type is loaded lazily.
A dispatcher for the
AgentBuilder.InitializationStrategy.SelfInjection.Lazy strategy.A form of self-injection where auxiliary types that are annotated by
AuxiliaryType.SignatureRelevant of the instrumented type are loaded lazily and
any other auxiliary type is loaded eagerly.A dispatcher for the
AgentBuilder.InitializationStrategy.SelfInjection.Split strategy.A strategy for injecting auxiliary types into a class loader.
An injection strategy that does not permit class injection.
An injection strategy that uses bootstrap injection using an
Instrumentation instance.An injection strategy that uses JNA to inject classes.
An injection strategy that uses Java reflection.
An injection strategy that uses
sun.misc.Unsafe or jdk.internal.misc.Unsafe to inject classes.An injection strategy that uses a factory for creating an unsafe injector.
A listener that is notified during the installation and the resetting of a class file transformer.
An adapter implementation for an installation listener that serves as a convenience.
A compound installation listener.
A listener that suppresses any installation error.
A non-operational listener that does not do anything.
This installation listener prints the status of any installation to a
PrintStream.
Implements the instrumentation of the
LambdaMetafactory if this feature is enabled.A factory that creates instances that represent lambda expressions.
Implements an explicit bridge method for a lambda expression.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation.Appender
An appender for implementing a bridge method for a lambda expression.
Implements a lambda class's executing transformer.
An appender to implement the executing transformer.
An implementation of a instance factory for a lambda expression's class.
An appender for a lambda expression factory.
Implements a lambda expression's functional method.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender
An appender for a lambda expression's functional method.
A dispatcher for a lambda expression's implementation.
An invocation that is using a direct call to the target method.
An invocation that is using an exact invocation of a method handle.
Implements the
writeReplace method for serializable lambda expressions.A factory for rewriting the JDK's
java.lang.invoke.LambdaMetafactory methods for use with Byte Buddy.A loader is responsible for loading a generated class file in the current VM.
An implementation that indicates that no loader is available.
A loader that uses a method handle lookup object to load a class.
A loader that is using unsafe API to load a lambda implementation.
A listener that is informed about events that occur during an instrumentation process.
An adapter for a listener where all methods are implemented as non-operational.
A compound listener that allows to group several listeners in one instance.
A listener that filters types with a given name from being logged.
A listener that adds read-edges to any module of an instrumented class upon its transformation and opens the class's package to the module.
A no-op implementation of a
AgentBuilder.Listener.A listener that writes events to a
PrintStream.A listener that only delegates events if they are failed transformations.
A listener that only delegates events if they are successful or failed transformations.
A strategy for creating a
ClassFileLocator when instrumenting a type.A compound location strategy that applies a list of location strategies.
A location strategy that locates class files by querying an instrumented type's
ClassLoader.A location strategy that never locates any byte code.
A simple location strategy that queries a given class file locator.
An abstraction for extending a matcher.
A type locator allows to specify how
TypeDescriptions are resolved by an AgentBuilder.
A type locator that attempts loading a type if it cannot be located by the underlying lazy type pool.
A default type locator that resolves types only if any property that is not the type's name is requested.
A type locator that resolves all type descriptions eagerly.
A type locator that uses type pools but allows for the configuration of a custom cache provider by class loader.
An implementation of a type locator
AgentBuilder.PoolStrategy.WithTypePoolCache (note documentation of the linked class) that is based on a
ConcurrentMap.A matcher that allows to determine if a
AgentBuilder.Transformer
should be applied during the execution of a ClassFileTransformer that was
generated by an AgentBuilder.A conjunction of two raw matchers.
A disjunction of two raw matchers.
A raw matcher implementation that checks a
TypeDescription
and its ClassLoader against two suitable matchers in order to determine if the matched
type should be instrumented.A raw matcher indicating the state of a type's class loading.
Only matches loaded types that can be fully resolved.
A raw matcher that inverts a raw matcher's result.
A matcher that always or never matches a type.
An agent builder configuration that allows the registration of listeners to the redefinition process.
A matcher that determines if types should be resubmitted if it is not yet loaded.
A matcher for immediate resubmission that matches both of the supplied delegate matchers.
A matcher for immediate resubmission that matches either of the supplied delegate matchers.
A matcher for immediate resubmission that uses element matchers for each argument to determine a resubmission.
A trivial matcher for immediate resubmission.
A matcher that determines if types should be resubmitted if it is not yet loaded and if an exception is raised.
A matcher for resubmission upon an error that matches both of the supplied delegate matchers.
A matcher for resubmission upon an error that matches either of the supplied delegate matchers.
A matcher for resubmission upon error that uses element matchers for each argument to determine a resubmission.
A trivial matcher for resubmission upon an exception.
An agent builder configuration strategy that allows the definition of a discovery strategy.
An agent builder configuration that allows the configuration of a batching strategy.
An
AgentBuilder specification that requires a resubmission specification.A complete but extendable resubmission specification.
A redefinition strategy regulates how already loaded classes are modified by a built agent.
A batch allocator which is responsible for applying a redefinition in a batches.
A batch allocator that creates chunks with a fixed size as batch jobs.
A batch allocator that groups all batches by discriminating types using a type matcher.
A batch allocator that includes all types in a single batch.
A partitioning batch allocator that splits types for redefinition into a fixed amount of parts.
A slicing batch allocator that assures that any batch is within a certain size range.
An iterable that slices batches into parts of a minimum and maximum size.
An iterator that slices batches into parts of a minimum and maximum size.
A collector is responsible for collecting classes that are to be considered for modification.
A collector that applies a redefinition of already loaded classes.
A collector that applies a retransformation of already loaded classes.
An iterator that allows prepending of iterables to be applied previous to another iterator.
A strategy for discovering types to redefine.
An explicit discovery strategy that only attempts the redefinition of specific types.
A discovery strategy that considers all loaded types supplied by
Instrumentation.getAllLoadedClasses().An iterable that returns any loaded types and checks if any additional types were loaded during the last instrumentation.
A reiterating iterator that considers types that were loaded during an instrumentation.
A discovery strategy that simplifies the application of
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating by assuming that the
loaded classes that are returned by Instrumentation.getAllLoadedClasses() are always
returned in the same order.An iterable that reiterates over an array of loaded classes by the previously observed length.
An iterator that reiterates over an array of loaded classes by the previously observed length.
A discovery strategy that considers all loaded types supplied by
Instrumentation.getAllLoadedClasses().A dispatcher for interacting with the instrumentation API.
A listener to be applied during a redefinition.
A listener adapter that offers non-operational implementations of all listener methods.
A batch reallocator allows to split up a failed retransformation into additional batches which are reenqueed to the
current retransformation process.
A compound listener that delegates events to several listeners.
A compound iterable.
A compound iterator that combines several iterables.
A listener that halts a retransformation process upon an exception.
A non-operational listener.
A listener that invokes
Thread.sleep(long) prior to every batch but the first batch.A listener that writes events to a
PrintStream.A listener that invokes
Thread.yield() prior to every batch but the first batch.A resubmission enforcer determines if a non-loaded class should be scheduled for resubmission or be treated upon first load.
A resubmission enforcer that does not consider non-loaded classes.
A resubmission scheduler is responsible for scheduling a job that is resubmitting unloaded types that failed during retransformation.
A resubmission scheduler that schedules jobs at a fixed rate.
A cancelable allows to discontinue a resubmission job.
A cancelable for a
Future.A non-operational cancelable.
A resubmission scheduler that does not apply any scheduling.
A resubmission scheduler that schedules jobs with a fixed delay.
A resubmission strategy is responsible for enabling resubmission of types that failed to resubmit.
A disabled resubmission strategy.
An enabled resubmission strategy.
A key for a class loader that can only be used for looking up a preexisting value but avoids reference management.
A job that resubmits any matched type that previously failed during transformation.
A handler for resubmissions.
A set projection for a
ConcurrentHashMap.A key for a class loader that only weakly references the class loader.
Represents an installation of a resubmission strategy.
A transformer allows to apply modifications to a
DynamicType.A transformer for applying an
Advice where this advice class might reference types of both the agent's and the user's
class loader.An entry for an advice to apply.
An entry for an advice class where both entry and exit advice methods are declared by the different classes.
An entry for an advice class where both the (optional) entry and exit advice methods are declared by the same class.
A transformer that applies a build
Plugin.A decorator that allows to change the class file transformer that is registered.
A compound transformer decorator.
A transformer decorator that retains the original transformer.
A type strategy is responsible for creating a type builder for a type that is being instrumented.
Default implementations of type strategies.
A type strategy that applies a build
EntryPoint.
Parameters that are annotated with this annotation will be assigned an array of all arguments of the instrumented
method.
A directive for how an
AllArguments
annotation on an array is to be interpreted.A binder for handling the
AllArguments
annotation.Indicates that a field, method or parameter can only be
null.Indicates that a field, method or parameter can only be
null.Annotation appenders are capable of writing annotations to a specified target.
A default implementation for an annotation appender that writes annotations to a given byte consumer
represented by an ASM
AnnotationVisitor.A type visitor that visits all type annotations of a generic type and writes any discovered annotation to a
supplied
AnnotationAppender.Represents a target for an annotation writing process.
Target for an annotation that is written to a Java field.
Target for an annotation that is written to a Java method or constructor.
Target for an annotation that is written to a Java method or constructor parameter.
Target for an annotation that is written to a Java record component.
Target for an annotation that is written to a Java type.
An annotation description describes
Annotation meta data of a class without this class
being required to be loaded.An adapter implementation of an annotation.
An
InvocationHandler for implementing annotations.A builder for pragmatically creating
AnnotationDescription.A description of an already loaded annotation.
A latent description of an annotation value that is defined explicitly.
An annotation description that is linked to a given loaded annotation type which allows its representation
as a fully loaded instance.
A rendering dispatcher is responsible for resolving annotation descriptions to
String representations.Defines a list of annotation instances.
An abstract base implementation of an annotation list.
Represents an empty annotation list.
Represents a list of explicitly provided annotation descriptions.
Describes an array of loaded
Annotations as an annotation list.An annotation retention strategy decides if annotations that are contained within a class file are preserved upon redefining
or rebasing a method.
Describes a declaration source for annotations.
An annotation source that does not declare any annotations.
An annotation source that declares a given list of annotations.
A matcher for annotations that target a given element type.
An element matcher that matches the type of an annotation description.
Representation of an unloaded annotation value where all values represent either:
Primitive values (as their wrappers),
Strings or arrays of primitive types or strings.
A TypeDescription or an array of such a descriptions.
An EnumerationDescription or an array of such a description.
An AnnotationDescription or an array of such a description.
The represented values are not necessarily resolvable, i.e.An abstract base implementation of an unloaded annotation value.
A description of an
Annotation as a value of another annotation.A loaded version of the described annotation.
Represents a primitive value, a
String or an array of the latter types.Represents a trivial loaded value.
A property delegate for a constant annotation value.
A property delegate for an array type of a constant value.
A property delegate for a non-array type.
Describes a complex array that is the value of an annotation.
Represents a loaded complex array.
A description of an
Enum as a value of an annotation.A loaded representation of an enumeration value.
Represents an annotation's enumeration value for a runtime type that is not an enumeration type.
Represents a property with an enumeration constant that is not defined by an enumeration type.
Represents a property with an enumeration constant that is not defined by an enumeration type.
Represents an annotation value where its declared type does not fulfil an expectation.
A description of annotation value for a type that does not fulfil an expectation.
Describes an annotation value that does not match the annotation' type for a property.
Describes an annotation value for a property that is not assignable to it.
An annotation value for a type that could not be loaded.
Represents a missing type during an annotation's resolution.
Represents a missing annotation property which is not represented by a default value.
Describes an annotation value for a property that is not assignable to it.
A description of a
Class as a value of an annotation.A loaded annotation value for a given type.
A loaded variant of an
AnnotationValue.An abstract base implementation of a loaded annotation value.
A base implementation for an unresolved property.
A rendering dispatcher is responsible for resolving annotation values to
String representations.Represents the sort of an
AnnotationValue.Represents the state of an
AnnotationValue.An annotation value filter is responsible for determining which values should be skipped and rather be represented as an
annotation type's default values when writing an annotation to a class file.
A default implementation of an annotation value filter that applies the same strategy for any type, field or method.
A factory for creating an annotation value filter for an annotation's target.
Parameters that are annotated with this annotation will be assigned the value of the parameter of the source method
with the given parameter.
A binder for handling the
Argument
annotation.Determines if a parameter binding should be considered for resolving ambiguous method bindings.
Implementation of an
MethodDelegationBinder.AmbiguityResolver
that resolves two conflicting bindings by considering most-specific types of target method parameters in the same manner
as the Java compiler resolves bindings of overloaded method.This token is used to mark a one-to-one binding of a source method parameter to a target method parameter.
A representation of the precedence of a most specific primitive type in the Java programming language.
Allows accessing array values.
A
CollectionFactory that is capable of
creating an array of a given type with any number of given values.An array creator is responsible for providing correct byte code instructions for creating an array
and for storing values into it.
An array creator implementation for primitive types.
An array creator implementation for reference types.
Allows accessing the length of the array.
Matches an enumeration type.
A class visitor wrapper is used in order to register an intermediate ASM
ClassVisitor which
is applied to the main type created by a DynamicType.Builder but not
to any AuxiliaryTypes, if any.An abstract base implementation of an ASM visitor wrapper that does not set any flags.
An ordered, immutable chain of
AsmVisitorWrappers.An ASM visitor wrapper that allows to wrap declared fields of the instrumented type with a
AsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper.An entry describing a field visitor wrapper paired with a matcher for fields to be wrapped.
A field visitor wrapper that allows for wrapping a
FieldVisitor defining a declared field.
An ASM visitor wrapper that allows to wrap declared methods of the instrumented type with a
AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper.An entry describing a method visitor wrapper paired with a matcher for fields to be wrapped.
A method visitor wrapper that allows for wrapping a
MethodVisitor defining a declared method.A class visitor wrapper that does not apply any changes.
An assigner is responsible for converting some type
A to another type B if possible.An assigner that only allows to assign types if they are equal to another.
An assigner that does not allow any assignments.
Indicates for a type assignment, if a type casting should be applied in case that two types are not statically assignable.
A Java program that attaches a Java agent to an external process.
An auxiliary type that provides services to the instrumentation of another type.
Representation of a naming strategy for an auxiliary type.
A naming strategy for an auxiliary type which attempts an enumeration of types by using the hash code
of the instrumenting instance.
Creates a naming strategy that uses stable suffixes that are provided by the auxiliary types themselves.
A naming strategy for an auxiliary type which returns the instrumented type's name with a fixed extension
and a random number as a suffix.
A marker to indicate that an auxiliary type is part of the instrumented types signature.
Defines a binding priority for a target method.
An ambiguity resolver that considers the priority of a method as defined by the
BindingPriority
annotation.An element matcher that returns a fixed result.
An API that can be implemented by logging build systems to allow plugins to log information without depending on
a build system-specific logging API.
An abstract adapter implementation for a build logger.
A compound build logger.
A non-operational build logger that discards all statements.
A build logger that writes all statements to a
PrintStream.
A
ClassLoader that is capable of loading explicitly defined classes.
A
ByteArrayClassLoader which applies child-first semantics for the
given type definitions.An enumeration that prepends an element to another enumeration and skips the last element of the provided enumeration.
An enumeration without any elements.
A package lookup strategy for locating a package by name.
A creation action for a package lookup strategy.
A package lookup strategy for Java 9 or newer.
A package lookup strategy for a VM prior to Java 9.
A persistence handler decides on whether the byte array that represents a loaded class is exposed by
the
ClassLoader.getResourceAsStream(String) method.An action to define a URL that represents a class file.
A stream handler that returns the given binary representation.
A URL connection for a given byte array.
An enumeration that contains a single element.
An engine for receiving a class loading lock when loading a class.
A creation action for a synchronization strategy.
A synchronization engine for a VM that is aware of parallel-capable class loaders.
A synchronization engine for a VM that is aware of parallel-capable class loaders using method handles to respect module boundaries.
A synchronization engine for a VM that is not aware of parallel-capable class loaders.
An uninitialized synchronization strategy.
Instances of this class serve as a focus point for configuration of the library's behavior and as an entry point
to any form of code generation using the library.
An implementation fo the
values method of an enumeration type.A byte code appender for the type initializer of any enumeration type.
A byte code appender for the
values method of any enumeration type.A constructor strategy for implementing a Java record.
A byte code appender for accessors and the record constructor.
Implements the object methods of the Java record type.
The Byte Buddy agent provides a JVM
Instrumentation in order to allow Byte Buddy the
redefinition of already loaded classes.An agent provider is responsible for handling and providing the jar file of an agent that is being attached.
An agent provider for a temporary Byte Buddy agent.
An agent provider that supplies an existing agent that is not deleted after attachment.
An attachment provider is responsible for making the Java attachment API available.
An accessor for a JVM's attachment API.
Describes an external attachment to a Java virtual machine.
A simple implementation of an accessible accessor.
A simple implementation of an accessible accessor that attaches using a virtual machine emulation that does not require external attachment.
A simple implementation of an accessible accessor that allows for external attachment.
A canonical implementation of an unavailable accessor.
A compound attachment provider that attempts the attachment by delegation to other providers.
An attachment provider that uses Byte Buddy's attachment API emulation.
An attachment provider that locates the attach API directly from the system class loader expecting
an IBM J9 VM.
An attachment provider that locates the attach API directly from the system class loader, as possible since
introducing the Java module system via the
jdk.attach module.An attachment provider that is dependant on the existence of a tools.jar file on the local
file system.
An attachment provider that attempts to locate a
tools.jar from a custom location set via a system property.An attachment evaluator is responsible for deciding if an agent can be attached from the current process.
An attachment type evaluator that never requires external attachment.
An attachment type evaluator that checks a process id against the current process id.
An installation action for creating an attachment type evaluator.
A process provider is responsible for providing the process id of the current VM.
Supplies the current VM's process id.
A process provider for a Java 9 capable VM with access to the introduced process API.
A process provider for a legacy VM that reads the process id from its JMX properties.
A Maven plugin for applying Byte Buddy transformations during a build.
Matches elements which represent a Java class that is represented in the list or an inner class of the classes represented in the list.
A Byte Buddy plugin that transforms a project's production class files.
A Byte Buddy plugin that transforms a project's production class files where runtime class
path elements are not included.
A Byte Buddy plugin that transforms a project's production class files where runtime class
path elements are included.
A Byte Buddy plugin that transforms a project's test class files.
A
BuildLogger implementation for a Maven Log.A
Plugin.Engine.Listener that logs several relevant events during the build.A transformer that is applied during the plugin's execution.
A transformer for an explicitly configured plugin.
A transformer for a discovered plugin.
An appender that generates the byte code for a given method.
A compound appender that combines a given number of other byte code appenders.
A simple byte code appender that only represents a given array of
StackManipulations.An immutable description of both the operand stack size and the size of the local variable array that is
required to run the code generated by this
ByteCodeAppender.Implementations describe an element represented in byte code, i.e.
A token representing a byte code element.
A list of tokens.
ByteCodeElement.TypeDependant<T extends ByteCodeElement.TypeDependant<?,S>,S extends ByteCodeElement.Token<S>>
A type dependant describes an element that is an extension of a type definition, i.e.
A plugin that caches the return value of a method in a synthetic field.
Indicates the field that stores the cached value.
An offset mapping for the cached field.
Indicates methods that should be cached, i.e.
An advice class for caching a
boolean value.An advice class for caching a
byte value.An advice class for caching a
char value.An advice class for caching a
double value.An advice class for caching a
float value.An advice class for caching a
int value.An advice class for caching a
long value.An advice class for caching a reference value.
An advice class for caching a
short value.A matcher that remembers the results of previously matching an equal target.
A caching matcher with inline cache eviction.
Represents a constant representing any loaded Java
Class.A class constant for a non-primitive
Class.Locates a class file or its byte array representation when it is given its type description.
A compound
ClassFileLocator that chains several locators.
A class file locator that queries a class loader for binary representations of class files.
A privileged action for creating a proxy class loader for the boot class loader.
A class file locator that queries a class loader for binary representations of class files.
A class file locator that finds files from a standardized Java folder structure with
folders donating packages and class files being saved as
<classname>.class files
within their package folder.A Java agent that allows the location of class files by emulating a retransformation.
A delegate that is queried for loading a class.
A default implementation of a class loading delegate.
A privileged action for creating a proxy class loader for the boot class loader.
A class loading delegate that allows the location of explicitly registered classes that cannot
be located by a class loader directly.
A class loading delegate that accounts for a
sun.reflect.DelegatingClassLoader which
cannot load its own classes by name.Representation of a Java
Field.An action for creating a dispatcher.
An uninitialized version of a dispatcher for extracting a class loader's loaded classes.
Represents a field that could be located.
Represents a field that could not be located.
A dispatcher to interact with the
Instrumentation API.A non-operational class file transformer that remembers the binary format of a given class.
A class file locator that locates classes within a Java jar file.
A class file locator that locates class files by querying a Java module's
getResourceAsStream method.
A class file locator for a Java module that only references this module weakly.
A class file locator that locates classes within a Java jmod file.
A class file locator that reads class files from one or several URLs.
An action to create a class loader with the purpose of locating classes from an URL location.
A class file locator that cannot locate any class files.
A class file locator that discriminates by a type's package.
Represents a class file as binary data.
Represents a byte array as binary data.
A canonical representation of an illegal binary representation.
A simple class file locator that returns class files from a selection of given types.
A post processor for class files.
A class file post processor that delegates to an
ClassFileTransformer.A permission collection that implies all permissions.
A non-operation class file post processor.
A wrapper object for representing a validated class file version in the format that is specified by the
JVMS.
A locator for the executing VM's Java version.
A version locator for a resolved class file version.
A resolver for the current VM's class file version.
An unresolved version locator.
A class injector is capable of injecting classes into a
ClassLoader without
requiring the class loader to being able to explicitly look up these classes.An abstract base implementation of a class injector.
A class injector using a
Instrumentation to append to either the boot classpath
or the system class path.A dispatcher to interact with the instrumentation API.
A representation of the target to which Java classes should be appended to.
A class injector using JNA to invoke JNI's define class utility for defining a class.
A dispatcher for JNA class injection.
An action for creating a JNA dispatcher.
An unavailable dispatcher for JNA-based class injection.
A class injector that uses a
java.lang.invoke.MethodHandles$Lookup object for defining a class.A dispatcher for
java.lang.invoke.MethodHandles.A dispatcher for
java.lang.invoke.MethodHandles$Lookup.A class injector that uses reflective method calls.
A dispatcher for accessing a
ClassLoader reflectively.A creation action for a dispatcher.
A class injection dispatcher that is using reflection on the
ClassLoader methods.A resolved class dispatcher for a class injector on a VM running at least Java 7.
A resolved class dispatcher for a class injector prior to Java 7.
Initializes a dispatcher to make non-accessible APIs accessible.
Represents an unsuccessfully loaded method lookup.
Represents an unsuccessfully loaded method lookup.
An indirect dispatcher that uses a redirection accessor class that was injected into the bootstrap class loader.
A dispatcher implementation that uses
sun.misc.Unsafe#putBoolean to set the AccessibleObject field
for making methods accessible.A resolved class dispatcher using unsafe field injection for a class injector on a VM running at least Java 7.
A resolved class dispatcher using unsafe field injection for a class injector prior to Java 7.
A proxy of
java.lang.System.A class injector that uses
sun.misc.Unsafe or jdk.internal.misc.Unsafe to inject classes.A dispatcher for using
sun.misc.Unsafe or jdk.internal.misc.Unsafe.A privileged action for creating a dispatcher.
An enabled dispatcher.
A class injection dispatcher that is not yet initialized.
A disabled dispatcher.
A factory for creating a
ClassInjector that uses sun.misc.Unsafe if available but attempts a fallback
to using jdk.internal.misc.Unsafe if the jdk.internal module is not resolved or unavailable.An access resolver that invokes
AccessibleObject.setAccessible(boolean) to true in a given privilege scope.A default access resolver that uses Byte Buddy's privilege scope.
A proxy of
java.lang.System.An element matcher that matches all
ClassLoaders in the matched class loaders hierarchy
against a given matcher.An element matcher that matches a class loader for being a parent of the given class loader.
A resolver that transforms a Maven coordinate into a class loader that can view the dependencies implied by this coordinate.
A strategy for loading a collection of types.
A
ClassLoadingStrategy that allows configuring the strategy's behavior.This class contains implementations of default class loading strategies.
A class loading strategy which applies a class loader injection while applying a given
ProtectionDomain on class injection.A class loading strategy which creates a wrapping class loader while applying a given
ProtectionDomain on class loading.A class loading strategy which allows class injection into the bootstrap class loader if
appropriate.
A class loading strategy that injects a class using JNA via the JNI DefineClass method.
A class loading strategy that injects a class using
sun.misc.Unsafe or jdk.internal.misc.Unsafe.A class loading strategy that uses a
java.lang.invoke.MethodHandles$Lookup instance for defining types.
The class reloading strategy allows to redefine loaded
Classes.A strategy to apply for injecting classes into the bootstrap class loader.
A disabled bootstrap injection strategy.
An enabled bootstrap class loader injection strategy.
A dispatcher to interact with the instrumentation API.
A strategy which performs the actual redefinition of a
Class.A class file transformer that applies a given
ClassDefinition.A transformer that indicates that a class file should not be transformed.
A class writer strategy is responsible for the creation of a
ClassWriter when creating a type.Default implementations of class writer strategies.
A class writer that piggy-backs on Byte Buddy's
TypePool to avoid class loading or look-up errors when redefining a class.A matcher that matches a given element of a collection.
An element matcher that matches a collection of types by their erasures.
Implementations of this interface are able to create collection types (including arrays) by sequentially
storing given values that must be compatible to the collection factory's component type.
A list item matcher matches any element of a collection to a given matcher and assures that at least one
element matches the supplied iterable condition.
An element matcher that matches a given iterable collection to a list of matchers on a per-element basis.
An element matcher that matches a collection by its size.
Creates a list representation of two lists as a single, compound list.
A comparator for guaranteeing a stable order for declared
Constructors.A constructor strategy is responsible for creating bootstrap constructors for a
SubclassDynamicTypeBuilder.Default implementations of constructor strategies.
A wrapper for a default constructor strategy which additionally applies a method attribute appender factory.
A constructor strategy that creates a default constructor that invokes a super constructor with default arguments.
An configuration of a Maven coordinate.
This interface represents all elements that can be declared within a type, i.e.
Indicates that this element must always be declared by a type.
An element matcher that matches the list of annotations that are provided by an annotated element.
An element matcher that checks if a type description declares fields of a given property.
An element matcher that checks if a type description declares methods of a given property.
An element matcher that matches the declaring type of another element, only if this element is actually declared
in a type.
This ambiguity resolver matches that method out of two methods that is declared by the more specific type.
A type builder that decorates a type by allowing for the application of attribute changes and ASM visitor wrappers.
Parameters that are annotated with this annotation are assigned an instance of an auxiliary proxy type that allows calling
any default method of an interface of the instrumented type where the parameter type must be an interface that is
directly implemented by the instrumented type.
A binder for the
Default annotation.Locates the type which should be the base type of the created proxy.
A type locator that yields the target parameter's type.
A type locator that returns a given type.
A parameter with this annotation is assigned a proxy for invoking a default method that fits the intercepted method.
A binder for handling the
DefaultCall
annotation.A default method locator is responsible for looking up a default method to a given source method.
An explicit default method locator attempts to look up a default method in the specified interface type.
An implicit default method locator that only permits the invocation of a default method if the source
method itself represents a method that was defined on a default method interface.
A parameter with this annotation is assigned an instance of
Method which invokes a default method implementation of this method.A binder for the
DefaultMethod annotation.Loads the delegation method constant onto the stack.
A method locator is responsible for creating the super method call.
A method locator for an explicit target type.
A method locator for an implicit target type.
This
Implementation invokes a default method for the methods it instruments.The appender for implementing a
DefaultMethodCall.Represents a stack assignment that loads the default value of a given type onto the stack.
DefinedShapeMatcher<T extends ByteCodeElement.TypeDependant<S,?>,S extends ByteCodeElement.TypeDependant<?,?>>
An element matcher that matches a byte code's element's token against a matcher for such a token.
An element matcher that matches a Java descriptor.
Determines how and if plugins are discovered from the class path.
A plugin that adds an
HashCodeAndEqualsPlugin.Enhance annotation to any method of an
enhanced type where the annotation is not set.A stack manipulation that divides two numbers on the operand stack.
This class is responsible for loading any
double constant onto the operand stack.A stack manipulation for loading a
double value from a class's constant pool onto the operand stack.Duplicates a value that is lying on top of the stack.
A duplication that flips a value over the second value on the operand stack.
A dynamic type that is created at runtime, usually as the result of applying a
DynamicType.Builder or as the result of an
AuxiliaryType.A builder for creating a dynamic type.
An abstract base implementation of a dynamic type builder.
An adapter implementation of a dynamic type builder.
A delegator for a dynamic type builder delegating all invocations to another dynamic type builder.
A builder for a field definition.
A builder for an optional field definition.
An abstract base implementation for an optional field definition.
A builder for an optional field definition that allows for defining a value.
An abstract base implementation of an optional field definition that allows for defining a value.
An adapter for an optional field definition that allows for defining a value.
A builder for a field definition that allows for defining a value.
An inner type definition for defining a type that is contained within another type, method or constructor.
An inner type definition for defining a type that is contained within another type.
A builder for a method definition.
An abstract base implementation of a method definition.
An adapter implementation of a method definition.
A builder for defining an implementation of a method and optionally defining a type variable or thrown exception.
An abstract base implementation for defining an implementation of a method and optionally defining a type variable or thrown exception.
A builder for defining an implementation of a method.
An abstract base implementation for a builder optionally defining an implementation of a method.
A builder for optionally defining an implementation of a method.
A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or method parameter.
An abstract base implementation for defining an implementation of a method and optionally defining a type variable, thrown exception or parameter type.
A builder for optionally defining an annotation on a parameter.
An abstract base implementation for defining an annotation on a parameter.
An adapter implementation for defining an annotation on a parameter.
A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or method parameter.
An abstract base implementation for an initial parameter definition.
A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or a parameter type.
An abstract base implementation of an exception definition.
A builder for optionally defining an annotation on a parameter.
An abstract base implementation of a simple parameter definition.
An adapter implementation of a simple parameter definition.
A builder for a method definition with a receiver type.
An abstract base implementation of a method definition that can accept a receiver type.
A builder for defining an implementation of a method and optionally defining a type variable.
An abstract base implementation for defining an implementation of a method and optionally defining a type variable.
A builder for optionally defining an annotation for a type variable.
An abstract base implementation for defining an annotation on a parameter.
An adapter implementation for an annotatable type variable definition.
A builder for a record component definition.
A
DynamicType.Builder.RecordComponentDefinition as an optional build step.An abstract base implementation of a record definition.
A builder for a type variable definition.
An abstract base implementation of a type variable definition.
A default implementation of a dynamic type.
A default implementation of a loaded dynamic type.
A default implementation of an unloaded dynamic type.
A dynamic type that has been loaded into the running instance of the Java virtual machine.
A dynamic type that has not yet been loaded by a given
ClassLoader.An element matcher is used as a predicate for identifying code elements such as types, methods, fields or
annotations.
A junctions allows to chain different
ElementMatchers in a readable manner.A base implementation of
ElementMatcher.Junction.A conjunction matcher which only matches an element if both represented matchers constitute a match.
A disjunction matcher which matches an element against matchers in order to constitute a successful match.
An abstract base implementation that rejects null values.
A utility class that contains a human-readable language for creating
ElementMatchers.Binds the parameter type's default value to the annotated parameter, i.e.
A binder for the
Empty annotation.An entry point for a build tool which is responsible for the transformation's configuration.
Default implementations for an entry point.
Describes an enumeration value.
An adapter implementation of an enumeration description.
An enumeration description representing a loaded enumeration.
A latent description of an enumeration value.
Determines if a type describes an enumeration.
An element matcher that checks an object's equality to another object.
An implementation of
Object.equals(Object) that takes a class's declared fields into consideration.A byte code appender to implement the
EqualsMethod.A compound comparator that compares the values of multiple fields.
A conditional return aborts the equality computation if a given condition was reached.
A comparator that retains the natural order.
Guards a field value against a potential
null value.A non-operational null value guard.
A null value guard that expects a reference type and that skips the comparison if both values are
null but returns if
the invoked instance's field value is null but not the compared instance's value.Checks the equality contract against the super class.
Checks the overall type of the provided argument.
A comparator that sorts fields by a type property.
A value comparator is responsible to compare to values of a given type.
An element matcher that matches its argument's
TypeDescription.Generic raw type against the
given matcher for a TypeDescription.This implementation causes a
Throwable to be thrown when the instrumented method is invoked.A construction delegate is responsible for calling a
Throwable's constructor.A construction delegate that calls the default constructor.
A construction delegate that calls a constructor that takes a single string as its argument.
A
MethodVisitor that adds a callback after visiting the exception table of a method.A fail-safe matcher catches exceptions that are thrown by a delegate matcher and returns an alternative value.
An access representation to a given field.
Representation of a field access for which a getter and a setter can be created.
A dispatcher for implementing a generic read or write access on a field.
Defines a method to access a given field by following the Java bean conventions for getters and setters:
A field accessor that can be configured to use a given assigner and runtime type use configuration.
A field location represents an identified field description which depends on the instrumented type and method.
An absolute field description representing a previously resolved field.
A prepared field location.
A relative field location where a field is located dynamically.
A prepared version of a field location.
A field name extractor is responsible for determining a field name to a method that is implemented
to access this method.
A
FieldAccessor.FieldNameExtractor that determines a field name
according to the rules of Java bean naming conventions.A field name extractor that returns a fixed value.
A field accessor for an implicit property where a getter or setter property is inferred from the signature.
A field accessor for a field setter.
An instrumentation that sets a constant value to a field.
A setter instrumentation that sets a
null or a primitive type's default value.A setter that reads a value of another field and sets this value.
A setter instrumentation for a parameter value.
An instrumentation that sets a field to a reference value that is stored in a static field of the instrumented type.
A termination handler is responsible for handling a field accessor's return.
A field accessor that can be configured to locate a field in a specific manner.
A field accessor that allows to define the access to be a field write of a given argument.
An appender that writes attributes or annotations to a given ASM
FieldVisitor.A field attribute appender that combines several method attribute appenders to be represented as a single
field attribute appender.
Appends an annotation to a field.
A factory that creates field attribute appenders for a given type.
A field attribute appender factory that combines several field attribute appender factories to be
represented as a single factory.
An attribute appender that writes all annotations that are declared on a field.
A field attribute appender that does not append any attributes.
A comparator for guaranteeing a stable order for declared
Fields.Represents a
Field constant for a given type.A cached version of a
FieldConstant.Implementations of this interface describe a Java field.
An abstract base implementation of a field description.
An implementation of a field description for a loaded field.
Represents a field in its defined shape, i.e.
An abstract base implementation of a field description in its defined shape.
Represents a field description in its generic shape, i.e.
A latent field description describes a field that is not attached to a declaring
TypeDescription.A token that uniquely identifies a field by its name and type erasure.
A token representing a field's properties detached from a type.
A field description that represents a given field but with a substituted field type.
Implementations represent a list of field descriptions.
An abstract base implementation of a
FieldList.An implementation of an empty field list.
A wrapper implementation of a field list for a given list of field descriptions.
An implementation of a field list for an array of loaded fields.
A list of field descriptions for a list of detached tokens.
A list of field descriptions that yields
FieldDescription.TypeSubstituting.A field locator offers an interface for locating a field that is declared by a specified type.
An abstract base implementation of a field locator.
A factory for creating a
FieldLocator.A field locator that looks up fields that are declared within a class's class hierarchy.
A factory for creating a
FieldLocator.ForClassHierarchy.A field locator that only looks up fields that are declared by a specific type.
A factory for creating a
FieldLocator.ForExactType.A field locator that only locates fields in the top-level type.
A factory for locating a field in a top-level type.
A field locator that never discovers a field.
A resolution for a field lookup.
An illegal resolution.
A simple implementation for a field resolution.
Describes the manifestation of a class's field, i.e.
Describes the persistence of a field, i.e.
Using this annotation it is possible to access fields by getter and setter types.
A binder for the
FieldProxy annotation.A proxy type for accessing a field either by a getter or a setter.
Implementation for a getter method.
A resolver for creating an instrumentation for a field access.
A factory for creating a field resolver.
A duplex factory for a type that both sets and gets a field value.
A simplex factory where field getters and setters both have their own type.
A field resolver for a getter accessor.
A field resolver for an accessor that both gets and sets a field value.
A field resolver for a setter accessor.
An unresolved field resolver.
Implementation for a setter method.
Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
An appender for implementing an
FieldProxy.Binder.InstanceFieldConstructor.Represents an implementation for implementing a proxy type constructor when a static field is accessed.
A field registry represents an extendable collection of fields which are identified by their names that are mapped
to a given
FieldAttributeAppender.Represents a compiled field registry.
A no-op field registry that does not register annotations for any field.
An immutable default implementation of a field registry.
A compiled default field registry.
An entry of a compiled field registry.
An entry of the default field registry.
An element matcher that matches a field's type.
Assigns the value of a field of the instrumented type to the annotated parameter.
Binds a
FieldValue annotation.A delegate implementation for the
FieldValue.Binder.A dispatcher to interact with the file system.
A file system representation for a VM that does not support NIO2.
A file system representation for a VM that does support NIO2.
A dispatcher to resolve a
File to a java.nio.file.Path.A dispatcher to access the
java.nio.file.Files API.A dispatcher to interact with
java.nio.file.StandardCopyOption.A filterable list allows to use an
ElementMatcher to reduce a lists to elements
that are matched by this matcher in this list.A base implementation of a
FilterableList.An implementation of an empty
FilterableList.This implementation returns a fixed value for a method.
Represents a fixed value implementation that is using a default assigner for attempting to assign
the fixed value to the return type of the instrumented method.
A fixed value implementation that returns a method's argument.
A fixed value of
null.A fixed value that appends the origin type of the instrumented type.
A fixed value implementation that represents its fixed value as a value that is written to the instrumented
class's constant pool.
A fixed value of
this.A byte code appender for returning
this.A fixed value implementation that represents its fixed value as a static field of the instrumented class.
This class is responsible for loading any
float constant onto the operand stack.A stack manipulation for loading a
float value from a class's constant pool onto the operand stack.
An assigner implementation that considers generic type assignability.
A visitor for generic types that determines assignability of such types.
A visitor for determining assignability of a generic array type.
An implementation of a assignability visitor that is applicable for any non-wildcard type.
A visitor for determining assignability of a non-generic type.
A visitor for determining the assignability of a parameterized type.
A visitor for determining assignability of a type in a type hierarchy, i.e.
A visitor to determine the assignability of a wildcard type.
Resolves a public method for a given type or returns
null if the type or method are not available or
if a resolution is not possible.An action for reading a system property as a privileged action.
A utility that resolves Graal VM native image properties.
A privileged action to resolve the image code via the current JVM processes input arguments, if available.
An exact invocation of a method handle with a polymorphic signature.
A build tool plugin that adds
Object.hashCode() and Object.equals(Object) methods to a class if the
HashCodeAndEqualsPlugin.Enhance annotation is present and no explicit method declaration was added.A comparator that arranges fields in the order of
HashCodeAndEqualsPlugin.Sorted.Instructs the
HashCodeAndEqualsPlugin to generate Object.hashCode() and Object.equals(Object) for the annotated
class unless these methods are already declared explicitly.A strategy for determining the base value of a hash code or equality contract.
Determines the sort order of fields for the equality check when implementing the
Object.equals(Object) method.Determines how a field should be used within generated hash code and equality methods.
Determines how a field should be handled.
An element matcher for a
HashCodeAndEqualsPlugin.ValueHandling annotation.A version of the
HashCodeAndEqualsPlugin that assumes that all fields are non-nullable unless they are explicitly marked.An implementation of
Object.hashCode() that takes a class's declared fields into consideration.A byte code appender to implement a hash code method.
A guard against
null values for fields with reference types.A non-operational null value guard.
A null value guard that expects a reference type and that uses a jump if a field value is
null.An offset provider is responsible for supplying the initial hash code.
An offset provider that uses the instance's class's hash code.
An offset provider that supplies a fixed value.
An offset provider that uses the instrumented type's class constant's hash code.
An offset provider that invokes the super class's
Object.hashCode() implementation.A value transformer that is responsible for resolving a field value to an
int value.An element matcher that matches a super class.
An element matcher that matches a super type.
Indicates that a given target method should never be considered for binding to a source method.
A non-instantiable type that allows to check if a method should be ignored for binding.
An implementation is responsible for implementing methods of a dynamically created type as byte code.
Represents an implementation that can be chained together with another implementation.
A compound implementation that allows to combine several implementations.
A compound implementation that allows to combine several implementations and that is
Implementation.Composable.The context for an implementation application.
A default implementation of an
Implementation.Context.ExtractableView
which serves as its own MethodAccessorFactory.A base implementation of a method that accesses a property of an instrumented type.
A description of an accessor method to access another method from outside the instrumented type.
An implementation of a
TypeWriter.MethodPool.Record for implementing
an accessor method.A description of a field that stores a cached value.
An abstract method pool entry that delegates the implementation of a method to itself.
A factory for creating a
Implementation.Context.Default
that uses a random suffix for accessors.A factory for creating a
Implementation.Context.Default
that uses a given suffix for accessors.A field cache entry for uniquely identifying a cached field.
A description of a field getter method.
An implementation for a field getter.
A description of a field setter method.
An implementation for a field setter.
An implementation context that does not allow for any injections into the static initializer block.
A factory for creating a
Implementation.Context.Disabled.Represents an extractable view of an
Implementation.Context which
allows the retrieval of any registered auxiliary type.An abstract base implementation of an extractable view of an implementation context.
A factory for creating a new implementation context.
A simple implementation that does not register any members with the instrumented type.
A dispatcher for a simple
Implementation, typically implemented as a lambda expression.A
ByteCodeAppender for a dispatcher.Represents an type-specific method invocation on the current instrumented type which is not legal from outside
the type such as a super method or default method invocation.
An abstract base implementation of a valid special method invocation.
A canonical implementation of an illegal
Implementation.SpecialMethodInvocation.A canonical implementation of a
Implementation.SpecialMethodInvocation.The target of an implementation.
An abstract base implementation for an
Implementation.Target.Determines if default method invocations are possible.
A factory for creating an
Implementation.Target.An element matcher that matches the list of inherited annotations of a type description.
Defines a configuration for a Maven build's type transformation.
An injection class loader allows for the injection of a class after the class loader was created.
A class loading strategy for adding a type to an injection class loader.
A latent method matcher that identifies methods to instrument when redefining or rebasing a type.
An installer class which defined the hook-in methods that are required by the Java agent specification.
Implements an
instanceof check.An element matcher that matches an object's type.
Implementations of this interface represent an instrumented type that is subject to change.
A default implementation of an instrumented type.
A factory for creating an
InstrumentedType.Default implementations of instrumented type factories.
A frozen representation of an instrumented type of which the structure must not be modified.
Implementations are able to prepare an
InstrumentedType.A prepareable that does not alter the instrumented type.
Implementations represent an
InstrumentedType with a flexible name.This class is responsible for loading any
int constant onto the operand stack.A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
A stack manipulation that loads a JVM-integer value by a
BIPUSH operation which is
legal for single byte integer values.A stack manipulation that loads a JVM-integer value by a
SIPUSH operation which is
legal for up to two byte integer values.An adapter for adapting an
InvocationHandler.Allows for the configuration of an
Assigner
of an InvocationHandlerAdapter.An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in an instance field.An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in a static field.Allows the configuration of privileged lookup for the resolution of
Method
constants that are provided to the invocation handler.An implementation that applies a
dynamic method invocation.
An abstract delegator that allows to specify a configuration for any specification of an argument.
An invocation provider is responsible for loading the arguments of the invoked method onto the operand
stack and for creating the actual invoke dynamic instruction.
An argument provider is responsible for loading arguments to a bootstrapped method onto the operand
stack and providing the types of these arguments.
Represents wrapper types and types that could be stored in a class's constant pool as such
constant pool values.
An argument provider for a
boolean value.An argument provider for a
byte value.An argument provider for a
char value.An argument provider for a
Class constant.An argument provider for a
double value.An argument provider for an
Enum constant.Provides an argument from an existing field.
An argument provider for a field value with an explicit type.
An argument provider for a
float value.An argument provider for a value that is stored in a randomly named static field.
An argument provider for a
int value.An argument provider that loads a reference to the intercepted instance and all arguments of
the intercepted method.
An argument provider that loads all arguments of the intercepted method.
An argument provider for a Java instance.
An argument provider for a
long value.An argument provider that loads an argument of the intercepted method.
An argument provider for a method parameter with an explicit type.
An argument provider for the
null value.An argument provider for a
short value.An argument provider for a
String value.An argument provider that loads the intercepted instance.
A simple implementation of a resolved argument provider.
An invocation provider that requests a synthetic dynamic invocation where all arguments are explicitly
provided by the user.
A target for a synthetically bound method call.
Provides the name of the method that is to be bound by a dynamic method call.
A name provider that provides an explicit name.
A name provider that provides the name of the intercepted method.
Provides the return type that is requested from the bootstrap method.
Requests an explicit return type.
Requests the return type of the intercepted method.
A target for a dynamic method invocation.
Represents a resolved
InvokeDynamic.InvocationProvider.Target.A simple implementation of
InvokeDynamic.InvocationProvider.Target.Resolved.A termination handler is responsible to handle the return value of a method that is invoked via a
InvokeDynamic.Representation of an
InvokeDynamic implementation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method.Representation of an
InvokeDynamic implementation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method and
where the invocation target is implicit.An
InvokeDynamic invocation where the last argument is assigned its implicit type.An invoke dynamic implementation where the last argument is an implicitly typed method argument.
An invoke dynamic implementation where the last argument is an implicitly typed field value.
A step in the invoke dynamic domain specific language that allows to explicitly specify a field type for a reference value.
An invoker is a deliberate indirection to wrap indirect calls.
An element matcher that matches a named element only if is explicitly named.
Returns a Java instance of an object that has a special meaning to the Java virtual machine and that is not
available to Java in versions 6.
Represents a dynamically resolved constant pool entry of a class file.
Represents a
java.lang.invoke.MethodHandle object.A representation of a method handle's type.
A dispatcher to interact with
java.lang.invoke.MethodHandleInfo.A dispatcher to interact with
java.lang.invoke.MethodHandles.A dispatcher to interact with
java.lang.invoke.MethodHandles$Lookup.A dispatcher to interact with
java.lang.invoke.MethodType.Represents a
java.lang.invoke.MethodType object.A dispatcher for extracting information from a
java.lang.invoke.MethodType instance.A dispatcher to represent
java.lang.constant.ConstantDesc.A dispatcher to represent
java.lang.constant.ClassDesc.A dispatcher to represent
java.lang.constant.DirectMethodHandleDesc.A dispatcher to represent
java.lang.constant.DirectMethodHandleDesc$Kind.A dispatcher to represent
java.lang.constant.DynamicConstantDesc.A dispatcher to represent
java.lang.constant.MethodHandleDesc.A dispatcher to represent
java.lang.constant.MethodTypeDesc.Represents a trivial constant value that represents itself.
Represents a type constant.
A visitor to resolve a
JavaConstant based on its implementation.A non-operational implementation of a
JavaConstant.Visitor for a JavaConstant.A constant representing a
JavaConstant.A visitor to resolve a
JavaConstant to a ASM constant pool representation.
A dispatcher for creating a proxy that invokes methods of a type that is possibly unknown on the current VM.
Indicates that the method is supposed to return an array of the proxied type.
Indicates that a method is supposed to return a default value if a method or type could not be resolved.
An
Invoker that uses Byte Buddy's invocation context to use if dynamic class loading is not supported, for example on Android,
and that do not use secured contexts, where this security measure is obsolete to begin with.A dispatcher for handling a proxied method.
A dispatcher for invoking a constructor.
A dispatcher that creates an array.
A dispatcher that returns a fixed value.
A dispatcher for a non-primitive array type.
A dispatcher for returning a default value for a primitive array.
A dispatcher that performs an instance check.
A dispatcher for invoking a non-static proxied method.
A dispatcher for invoking a static proxied method.
A dispatcher for an unresolved method.
A class loader for loading synthetic classes for implementing a
JavaDispatcher.A resolver to make adjustments that are possibly necessary to withhold module graph guarantees.
An action to create a resolver.
A resolver for VMs that do support the module system.
A non-operational resolver for VMs that do not support the module system.
Indicates that a method is supposed to perform an instance check.
A privileged action for creating an
Invoker.Indicates that a proxied method is a constructor.
Indicates that a proxied method is static.
Indicates a proxied type's name.
An invocation handler that invokes given dispatchers.
Type-safe representation of a
java.lang.Module.A proxy for interacting with
java.lang.Module.A proxy for resolving a
Class's java.lang.Module.Representations of Java types that do not exist in Java 6 but that have a special meaning to the JVM.
A latent type that resolves the simple name without considering the declaring type which is not normally available.
This class serves as a dispatcher for creating lambda expression objects when Byte Buddy is configured to instrument the
java.lang.invoke.LambdaMetafactory.A latent matcher that resolves an
ElementMatcher after supplying a type description.A matcher that computes the conjunction of all supplied latent matchers.
A matcher that computes the disjunction of all supplied latent matchers.
A latent matcher where the field token is being attached to the supplied type description before matching.
A resolved matcher of a latent field matcher for a field token.
A latent matcher where the method token is being attached to the supplied type description before matching.
A resolved matcher of a latent method matcher for a method token.
A latent matcher for a record component token.
A latent matching methods that are declared by the resolved type.
A latent matcher representing an already resolved
ElementMatcher.A method visitor that maps the first available line number information, if available, to the beginning of the method.
Implementations of this interface explicitly initialize a loaded type.
A compound loaded type initializer that combines several type initializers.
A type initializer for setting a value for a static field.
A loaded type initializer that does not do anything.
A method visitor that traces the amount of used local variable slots.
This class is responsible for loading any
long constant onto the operand stack.A stack manipulation for loading a
long value from a class's constant pool onto the operand stack.Indicates if a member is mandated.
A Maven coordinate.
Indicates that a field, method or parameter can sometimes be
null.Indicates that a field, method or parameter can sometimes be
null.A visitor that adds attributes to a class member.
A visitor that adds attributes to a field.
A field visitor to apply an field attribute appender.
A visitor that adds attributes to a method.
A method visitor to apply a method attribute appender.
A visitor wrapper that removes fields or methods that match a given
ElementMatcher.A class visitor that removes members based on element matchers.
Substitutes field access or method invocations within a method's body.
A replacement combines a
MemberSubstitution.Substitution and a way of choosing if this substitution should be applied for a discovered member.A binding for a replacement of a field or method access within another method.
A binding that was resolved for an actual substitution.
An unresolved binding.
A factory for creating a replacement for an instrumented method.
A compound factory.
A replacement that substitutes a member based on a row of element matchers.
A factory for creating a replacement that chooses members based on a row of element matchers.
A replacement that only resolves the first matching replacement of a list of replacements.
Describes a method invocation type.
A non-operational replacement.
A method visitor that applies a substitution for matched methods.
A substitution replaces or enhances an interaction with a field or method within an instrumented method.
A substitution chain allows for chaining multiple substitution steps for a byte code element being replaced.
A factory for creating a substitution chain.
Represents a step of a substitution chain.
Resolves a substitution for an instrumented method.
A resolved substitution step.
A simple substitution step within a substitution chain.
A factory for creating a substitution for an instrumented method.
A substitution with a field access.
A method resolver for locating a field for a substitute.
A field matcher that resolves a non-static field on the first parameter type of the substituted member usage.
A simple field resolver that returns a specific field.
A factory for a substitution that substitutes with a given field.
A factory for a substitution that locates a field on the receiver type using a matcher.
A substitution with a method invocation.
A method resolver for locating a method for a substitute.
A method resolver that locates a non-static method by locating it from the receiver type.
A simple method resolver that returns a given method.
A factory for a substitution that invokes a given method.
A factory for a substitution that invokes the instrumented method.
A factory for a substitution that locates a method on the receiver type using a matcher.
A substitution that drops any field or method access and returns the expected return type's default value, i.e
null or zero for primitive types.A type pool resolver is responsible for resolving a
TypePool for locating substituted members.A type pool resolver that resolves the implicit pool but additionally checks another class file locator.
A type pool resolver that returns a specific type pool.
Returns the implicit type pool.
A member substitution that lacks a specification for how to substitute the matched members references within a method body.
Describes a member substitution that requires a specification for how to replace a byte code element.
Describes a member substitution that requires a specification for how to replace a field.
Describes a member substitution that requires a specification for how to replace a method or constructor.
A class visitor that traces invocations of visitation methods and notifies if a nest host or outer class was not visited.
A factory for creating method proxies for an auxiliary type.
Indicates the type of access to an accessor method.
A method accessor factory that forbids any accessor registration.
Describes if a method allows varargs arguments.
An appender that writes attributes or annotations to a given ASM
MethodVisitor.A method attribute appender that combines several method attribute appenders to be represented as a single
method attribute appender.
Appends an annotation to a method or method parameter.
Represents the target on which this method attribute appender should write its annotations to.
A method attribute appender target for writing annotations directly onto the method.
A method attribute appender target for writing annotations onto a given method parameter.
A factory that creates method attribute appenders for a given type.
A method attribute appender factory that combines several method attribute appender factories to be
represented as a single factory.
Implementation of a method attribute appender that writes all annotations of the instrumented method to the
method that is being created.
A method attribute appender that writes a receiver type.
A method attribute appender that does not append any attributes.
This
Implementation allows the invocation of a specified method while
providing explicit arguments to this method.An argument loader is responsible for loading an argument for an invoked method
onto the operand stack.
An argument provider is responsible for providing an argument loader for each argument to supply to a method.
A factory that produces
MethodCall.ArgumentLoaders for a given instrumented method.Loads the value of an existing field onto the operand stack.
An argument provider for a field access.
A factory for an argument loaded that loads the value of an existing field as an argument.
Loads a value onto the operand stack that is stored in a static field.
A factory that supplies the value of a static field as an argument.
Loads the instrumented type onto the operand stack.
A factory for an argument loader that supplies the instrumented type as an argument.
Loads the return value of a method call onto the operand stack.
An argument provider for a method call.
A factory for an argument loaded that loads the return value of a method call as an argument.
Loads a parameter of the instrumented method onto the operand stack.
A factory for an argument loader that supplies a method parameter as an argument.
A factory for argument loaders that supplies all arguments of the instrumented method as arguments.
Loads an array containing all arguments of a method.
A factory that creates an arguments loader that loads all parameters of the instrumented method contained in an array.
An argument loader that loads an element of a parameter of an array type.
An argument loader factory that loads an array element from a parameter for each argument of the invoked method.
Creates an argument loader for an array element that of a specific parameter.
An argument loader that loads the
null value onto the operand stack.Loads a stack manipulation resulting in a specific type as an argument.
An argument loader that assigns the
this reference to a parameter.A factory for an argument loader that supplies the
this value as an argument.A
MethodCall that sets the call's result as the value of a field.A byte code appender to implement a field-setting method call.
A method invoker is responsible for creating a method invocation that is to be applied by a
MethodCall.A factory for creating a method invoker.
Applies a contextual invocation of the provided method, i.e.
A factory for creating a contextual method invoker.
Invokes a method as a Java 8 default method.
A factory for creating a method invoker for a default method invocation.
Applies a super method invocation of the provided method.
A method invoker factory for a super method invocation.
Applies a virtual invocation on a given type.
A method invoker factory for a virtual method invocation.
A method invoker for a virtual method that uses an implicit target type.
A method locator is responsible for identifying the method that is to be invoked
by a
MethodCall.A factory for creating a method locator.
A method locator that identifies a unique virtual method.
A factory for a method locator that uses a matcher on the instrumented type's available methods for identifing a target method.
Invokes a given method.
A method locator that simply returns the intercepted method.
A target handler is responsible for invoking a method for a
MethodCall.A factory for creating a target handler.
Invokes a method in order to construct a new instance.
A target handler factory for a constructor invocation.
Creates a target handler that stores the instance to invoke a method on in an instance field.
A factory for a field access.
A location of a field.
An explicit field location.
An implicit field location.
A target handler that executes the method and uses it's return value as the target object.
Creates a factory for invoking a method on the return type of another method.
A resolved target handler for a method call.
A target handler that loads the parameter of the given index as the target object.
A resolved target handler for a method parameter.
A target handler that invokes a method either on the instance of the instrumented
type or as a static method.
A factory for invoking a static method or a self-declared method.
A resolved target handler for a static or self-declared invocation.
A target handler that invokes a method on an instance that is stored in a static field.
A factory for a target handler that loads a specific value.
A resolved target handler.
A simple target handler that applies a given stack manipulation.
A termination handler is responsible to handle the return value of a method that is invoked via a
MethodCall.A factory for creating a termination handler.
A termination handler that sets a field.
A factory for a field-setting termination handler that locates a given field.
A factory for a field-setting termination handler that uses a matcher to locate the target field on the insturmented type.
Simple termination handler implementations.
Represents a
MethodCall that invokes a method without specifying
an invocation method.A method call proxy represents a class that is compiled against a particular method which can then be called whenever
either its
Callable.call() or Runnable.run() method is called where the method
call proxy implements both interfaces.A stack manipulation that creates a
MethodCallProxy
for a given method an pushes such an object onto the call stack.An implementation for a constructor of a
MethodCallProxy.The appender for implementing the
MethodCallProxy.ConstructorCall.An implementation for a method of a
MethodCallProxy.A precomputed method graph that only displays the methods that are relevant for creating a method call proxy.
A comparator for guaranteeing a stable order for declared
Methods.Represents the creation of a
Method value which can be created from a given
set of constant pool values and can therefore be considered a constant in the broader meaning.Represents a cached constructor for a
MethodConstant.Represents a cached method for a
MethodConstant.Represents a
MethodConstant that is
directly loaded onto the operand stack without caching the value.Represents a method constant that cannot be represented by Java's reflection API.
Creates a
MethodConstant for loading
a Constructor instance onto the operand stack.Creates a
MethodConstant for loading
a Method instance onto the operand stack.Performs a privileged lookup of a method constant by using an
java.security.AccessController.This implementation delegates an method call to another method which can either be
static by providing
a reference to a Class or an instance method when another object is provided.The appender for implementing a
MethodDelegation.An implementation delegate is responsible for executing the actual method delegation and for resolving the target methods.
A compiled implementation delegate.
A compiled implementation delegate for a constructor delegation.
A compiled implementation delegate that invokes methods on a field.
A compiled implementation delegate that invokes a method on an instance that is returned by another method.
A compiled implementation delegate for invoking a static method.
An implementation delegate for constructing an instance.
An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.
An implementation target for a static field that is declared by the instrumented type and that is assigned an instance.
An implementation target for a field that is declared by the instrumented type or a super type.
An implementation delegate for invoking a delegation target on the another methods return value.
An implementation delegate for a static method delegation.
A
MethodDelegation with custom configuration.A method delegation binder is responsible for creating a method binding for a source method to a
target method.
Implementations of this interface are able to attempt the resolution of two successful bindings of a method
to two different target methods in order to identify a dominating binding.
A chain of
MethodDelegationBinder.AmbiguityResolvers
that are applied in the given order until two bindings can be resolved.An ambiguity resolver that always resolves in the specified direction.
An ambiguity resolver that does not attempt to resolve a conflicting binding.
A resolution state of an attempt to resolve two conflicting bindings.
A binding resolver is responsible to choose a method binding between several possible candidates.
A default implementation of a binding resolver that fully relies on an
MethodDelegationBinder.AmbiguityResolver.Binds a method using another resolver and prints the selected binding to a
PrintStream.A binding resolver that only binds a method if it has a unique binding.
A binding attempt created by a
MethodDelegationBinder.A mutable builder that allows to compose a
MethodDelegationBinder.MethodBinding
by adding parameter bindings incrementally.A method binding that was created by a
MethodDelegationBinder.MethodBinding.Builder.Representation of an attempt to bind a source method to a target method that is not applicable.
Implementations are used as delegates for invoking a method that was bound
using a
MethodDelegationBinder.A simple method invocation that merely uses the most general form of method invocation as provided by
MethodInvocation.A method invocation that enforces a virtual invocation that is dispatched on a given type.
A binding attempt for a single parameter.
An anonymous binding of a target method parameter.
A singleton representation of an illegal binding for a method parameter.
A uniquely identifiable parameter binding for a target method.
A helper class that allows to identify a best binding for a given type and source method choosing from a list of given
target methods by using a given
MethodDelegationBinder
and an MethodDelegationBinder.AmbiguityResolver.A method delegation that was compiled to a target method.
A compiled method delegation binder that only yields illegal bindings.
A termination handler is responsible for terminating a method delegation.
Responsible for creating a
StackManipulation
that is applied after the interception method is applied.Implementations of this interface describe a Java method, i.e.
An abstract base implementation of a method description.
An implementation of a method description for a loaded constructor.
An implementation of a method description for a loaded method.
Represents a method in its defined shape, i.e.
An abstract base implementation of a method description in its defined shape.
A proxy type for invoking methods of
java.lang.reflect.Executable.A base implementation for a loaded instance representation for a
java.lang.reflect.Executable.Represents a method description in its generic shape, i.e.
A latent method description describes a method that is not attached to a declaring
TypeDescription.A method description that represents the type initializer.
A token representing a method's name and raw return and parameter types.
A token representing a method's properties detached from a type.
A method description that represents a given method but with substituted method types.
A token representing a method's erased return and parameter types.
An element matcher that matches the exceptions that are declared by a method.
A method graph represents a view on a set of methods as they are seen from a given type.
A compiler to produce a
MethodGraph from a given type.An abstract base implementation of a method graph compiler.
A default implementation of a method graph.
A harmonizer is responsible for creating a token that identifies a method's relevant attributes for considering
two methods of being equal or not.
A harmonizer for the Java programming language that identifies a method by its parameter types only.
A token that identifies a Java method's type by its parameter types only.
A harmonizer for the Java virtual machine's method dispatching rules that identifies a method by its parameter types and return type.
A token that identifies a Java method's type by its parameter types and return type.
A key represents a collection of methods within a method graph to later yield a node representing a collection of methods,
i.e.
A detached version of a key that identifies methods by their JVM signature, i.e.
A harmonized key represents a key where equality is decided based on tokens that are returned by a
MethodGraph.Compiler.Default.Harmonizer.A store for collected methods that are identified by keys.
An entry of a key store.
An entry representing an ambiguous node resolution.
A node implementation representing an ambiguous method resolution.
An entry in its initial state before registering any method as a representative.
An entry representing a non-ambiguous node resolution.
A node implementation representing a non-ambiguous method.
A graph implementation based on a key store.
Implementations are responsible for identifying a representative method for a
MethodGraph.Node
between several ambiguously resolved methods.A directional merger that always returns either the left or right method description.
A flat compiler that simply returns the methods that are declared by the instrumented type.
A canonical implementation of an empty method graph.
A linked method graph represents a view that additionally exposes information of a given type's super type view and a
view on this graph's directly implemented interfaces.
A simple implementation of a linked method graph that exposes views by delegation to given method graphs.
Represents a node within a method graph.
A simple implementation of a resolved node of a method without bridges.
Represents a
MethodGraph.Node's state.A canonical implementation of an unresolved node.
A list of nodes.
A simple implementation of a method graph.
A builder for a method invocation.
Performs a method invocation on a method handle with a polymorphic type signature.
The type of method handle invocation.
An illegal implicit method invocation.
A method invocation of a generically resolved method.
Represents a method invocation where the invocation type (static, virtual, special, interface) is derived
from the given method's description.
Implementations represent a list of method descriptions.
A base implementation of a
MethodList.An implementation of an empty method list.
A method list that is a wrapper for a given list of method descriptions.
A method list implementation that returns all loaded byte code methods (methods and constructors) that
are declared for a given type.
A list of method descriptions for a list of detached tokens.
A list of method descriptions that yields
MethodDescription.TypeSubstituting.Describes the manifestation of a method, i.e.
Implementation of an
MethodDelegationBinder.AmbiguityResolver
that resolves conflicting bindings by considering equality of a target method's name as an indicator for a dominant
binding.A method name transformer provides a unique mapping of a method's name to an alternative name.
A method name transformer that adds a fixed prefix to an original method name.
A method name transformer that adds a fixed suffix to an original method name, separated by a
$.A matcher that checks if any super type of a type declares a method with the same shape of a matched method.
An element matcher that matches a method's parameters.
An element matcher that matches a method's parameter's type.
An element matcher that matches a method's parameter types.
A method rebase resolver is responsible for mapping methods of an instrumented type to an alternative signature.
A default implementation of a method rebase resolver.
A method rebase resolver that preserves any method in its original form.
A resolution for a method that was checked by a
MethodRebaseResolver.A
MethodRebaseResolver.Resolution of a rebased constructor.An description of a rebased constructor.
A
MethodRebaseResolver.Resolution of a rebased method.A description of a rebased method.
A
MethodRebaseResolver.Resolution of a non-rebased method.A method registry is responsible for storing information on how a method is intercepted.
A compiled version of a method registry.
A default implementation of a method registry.
A compiled version of a default method registry.
An entry of a compiled method registry.
An entry of a default method registry.
A prepared version of a default method registry.
An entry of a prepared method registry.
A handler for implementing a method.
A compiled handler for implementing a method.
A handler for defining an abstract or native method.
A handler for defining a default annotation value for a method.
A handler for a method that is implemented as byte code.
A compiled handler for implementing a method.
A handler for implementing a visibility bridge.
A compiled handler for a visibility bridge handler.
A method registry that fully prepared the instrumented type.
A stack manipulation returning a value of a given type.
An element matcher that matches its argument's return type against a given type matcher.
Matches a method description by its general characteristics which are represented as a
MethodSortMatcher.Sort.Represents a specific characteristic of a method description.
A modifier contributor to determine the use of
strictfp on a method.A stack assignment that loads a method variable from a given index of the local variable array.
A stack manipulation that loads all parameters of a given method onto the operand stack.
A type casting handler allows a type transformation of all arguments of a method after loading them onto the operand stack.
A type casting handler that casts all parameters of a method to the parameter types of a compatible method
with covariant parameter types.
A non-operative type casting handler.
A stack manipulation that increments an integer variable.
A visitor wrapper that adjusts the modifiers of the instrumented type or its members.
A description of a conditional adjustment.
A class visitor that enforces a collection of modifier adjustments.
An element that describes a type modifier as described in the
JVMS.
A marker interface for modifiers that can be applied to fields.
A marker interface for modifiers that can be applied to methods.
A marker interface for modifiers that can be applied to method parameters.
A marker interface for modifiers that can be applied to types.
A resolver for Java modifiers represented by
ModifierContributors.An element matcher that matches a byte code element by its modifiers.
Determines the type of modifier to be matched by a
ModifierMatcher.Implementations of this interface can be described in terms of a Java modifier.
An abstract base implementation of a
ModifierReviewable class.A modifier reviewable for a
FieldDescription.A modifier reviewable for a
MethodDescription.A modifier reviewable for a
ParameterDescription.A modifier reviewable for a
TypeDescription.A modifier reviewable for a byte code element that can be abstract, i.e.
A modifier reviewable for a
ByteCodeElement, i.e.A modifier reviewable for a byte code element that can represent an enumeration, i.e.
This annotation instructs Byte Buddy to inject a proxy class that calls a method's super method with
explicit arguments.
A binder for the
Morph annotation.A default method locator is responsible for looking up a default method to a given source method.
An explicit default method locator attempts to look up a default method in the specified interface type.
An implicit default method locator that only permits the invocation of a default method if the source
method itself represents a method that was defined on a default method interface.
A proxy that implements the installed interface in order to allow for a morphed super method invocation.
Creates an instance of the proxy when instrumenting an instance method.
The byte code appender that implements the constructor.
Implements a the method call of the morphing method.
Creates an instance of the proxy when instrumenting a static method.
This
ClassLoader is capable of loading classes from multiple parents.A builder to collect class loader and that creates a
MultipleParentClassLoader only if multiple or no
ClassLoaders are found in the process.A compound URL enumeration.
A stack manipulation that multiplies two numbers on the operand stack.
Represents a Java element with a name.
A named element with a class file descriptor and a generic signature.
A named element with a generic type name.
Describes a named element where naming the element is optional and an alternative default name is provided if no explicit name is given.
A named element with a name that has a particular meaning to the Java runtime.
A method matcher that matches a byte code element's source code name:
The source code name of types is equal to their binary name where arrays are appended a
[] by
their arity and where inner classes are appended by dollar signs to their outer class's source name.
Constructors and the type initializer methods are represented by the empty string as they do not
represent a source code name.
Fields are named as in the source code.
A naming strategy for determining a fully qualified name for a dynamically created Java type.
An abstract base implementation where the names of redefined and rebased types are retained.
A naming strategy that creates a name by prefixing a given class and its package with another package and
by appending a random number to the class's simple name.
A naming strategy that appends a given suffix to a name, without a randomized element.
A base name resolver is responsible for resolving a name onto which the suffix is appended.
A base name resolver that simply returns a fixed value.
Uses a specific type's name as the resolved name.
Uses the unnamed type's super type's name as the resolved name.
A base name resolver that adds the name of the class that is invoking
ByteBuddy.A naming strategy that creates a name by concatenating:
The super classes package and name
A given suffix string
A random number
Between all these elements, a
$ sign is included into the name to improve readability.Deprecated.
Deprecated.
Deprecated.
Deprecated.
An element matcher that reverses the matching result of another matcher.
Indicates that a field, method or parameter can never be
null.Indicates that a field, method or parameter can never be
null.Indicates that any field, method return or method and constructor parameter of a package is never
null.Indicates that any field, method return or method and constructor parameter of a package is never
null.
This nexus is a global dispatcher for initializing classes with
LoadedTypeInitializers.The Nexus accessor is creating a VM-global singleton
Nexus such that it can be seen by all class loaders of
a virtual machine.A dispatcher for registering type initializers in the
Nexus.An enabled dispatcher for registering a type initializer in a
Nexus.Creates a new dispatcher for accessing a
Nexus.A disabled dispatcher where a
Nexus is not available.An initialization appender that looks up a loaded type initializer from Byte Buddy's
Nexus.Represents a stack manipulation to load a
null pointer onto the operand stack.An element matcher that matches the
null value.A
ClassReader that does not apply a class file version check if the net.bytebuddy.experimental property is set.
The origin annotation provides some meta information about the source method that is bound to this method where
the binding is dependant of the parameter's type:
A binder for binding parameters that are annotated with
Origin.Determines the ownership of a field or method, i.e.
A package definer is responsible for defining a package's properties when a class of a new package is loaded.
A definition of a package.
A simple package definition where any property is represented by a value.
A package definer that defines packages without any meta data.
A canonical implementation of an undefined package.
A package definer that reads a class loader's manifest file.
A locator for a seal base URL.
A seal base locator that seals all packages with a fixed URL.
A seal base locator that imitates the behavior of a
URLClassLoader, i.e.A seal base locator that never seals a package.
A package definer that does not define any package.
A package definer that only defines packages without any meta data.
A package description represents a Java package.
An abstract base implementation of a package description.
Represents a loaded
Package wrapped as a
PackageDescription.A simple implementation of a package without annotations.
Description of the parameter of a Java method or constructor.
A base implementation of a method parameter description.
Description of a loaded parameter with support for the information exposed by
java.lang.reflect.Parameter.A description of a loaded
Constructor parameter for a modern VM.Description of a loaded constructor's parameter on a virtual machine where
java.lang.reflect.Parameter
is not available.Description of a loaded method's parameter on a virtual machine where
java.lang.reflect.Parameter
is not available.A description of a loaded
Method parameter for a modern VM.A proxy for a
java.lang.reflect.Parameter.A source for querying parameter annotations.
A source for a loaded constructor.
A source for a loaded method.
Represents a parameter in its defined shape, i.e.
An abstract base implementation of a parameter description in its defined shape.
Represents a parameter description in its generic shape, i.e.
A latent description of a parameter that is not attached to a method or constructor.
A token representing a parameter's properties detached from a type.
A list of types represented as a list of parameter tokens.
A parameter description that represents a given parameter but with a substituted parameter type.
This
MethodDelegationBinder.AmbiguityResolver selects
the method with more arguments.Represents a list of parameters of a method or a constructor.
An base implementation for a
ParameterList.An empty list of parameters.
A list of explicitly provided parameter descriptions.
A parameter list representing parameters without meta data or annotations.
Represents a list of parameters for an executable, i.e.
A dispatcher for creating descriptions of parameter lists and for evaluating the size of an
java.lang.reflect.Executable's parameters.Describes the list of
Constructor parameters on a modern VM.Represents a list of constructor parameters on virtual machines where the
java.lang.reflect.Parameter
type is not available.Represents a list of method parameters on virtual machines where the
java.lang.reflect.Parameter
type is not available.Describes the list of
Method parameters on a modern VM.A list of parameter descriptions for a list of detached tokens.
A list of parameter descriptions that yields
ParameterDescription.TypeSubstituting.Indicates whether a parameter was denoted as
final or not.
A target method parameter that is annotated with this annotation allows to forward an intercepted method
invocation to another instance.
A
TargetMethodAnnotationDrivenBinder.ParameterBinder
for binding the Pipe annotation.An auxiliary type for performing the redirection of a method invocation as requested by the
Pipe annotation.The implementation to implement a
Pipe.Binder.RedirectionProxy's constructor.The appender for implementing the
Pipe.Binder.RedirectionProxy.ConstructorCall.The implementation to implement a
Pipe.Binder.RedirectionProxy's forwarding method.
A plugin that allows for the application of Byte Buddy transformations during a build process.
A plugin engine allows the application of one or more plugins on class files found at a
Plugin.Engine.Source which are
then transferred and consumed by a Plugin.Engine.Target.An abstract base implementation of a plugin engine.
A default implementation of a plugin engine.
A dispatcher to execute a plugin engine transformation.
A factory that is used for creating a dispatcher that is used for a specific plugin engine application.
A dispatcher that applies transformations within one or more threads in parallel to the default transformer.
An eager materialization that does not defer processing after preprocessing.
A factory for a dispatcher that uses a given executor service for parallel dispatching.
A parallel dispatcher that shuts down its executor service upon completion of a plugin engine's application.
A factory for a parallel executor service that creates a new executor service on each plugin engine application.
A dispatcher that applies transformation upon discovery.
A factory for creating a serial dispatcher.
The result of a work assignment that needs to be invoked from the main thread that triggers a dispatchers life-cycle methods.
A materializable for an element that failed to be transformed.
A materializable for an element that is retained in its original state.
A materializable for a successfully transformed type.
A materializable for an element that could not be resolved.
An error handler that is used during a plugin engine application.
A compound error handler.
An error handler that enforces certain properties of the transformation.
An implementation of an error handler that fails the plugin engine application.
A listener that is invoked upon any event during a plugin engine application.
An adapter that implements all methods non-operational.
A compound listener.
A listener decorator that forwards events to an error handler if they are applicable.
A non-operational listener.
A listener that forwards significant events of a plugin engine application to a
PrintStream.A decorator for another listener to only print error events.
A decorator for another listener to only print transformation and error events.
A pool strategy determines the creation of a
TypePool for a plugin engine application.A default implementation of a pool strategy where type descriptions are resolved lazily.
A pool strategy that resolves type descriptions eagerly.
A source for a plugin engine provides binary elements to consider for transformation.
Represents a binary element found in a source location.
An element representation for a byte array.
An element representation for a file.
Represents a jar file entry as an element.
An empty source that does not contain any elements or a manifest.
A source that applies a filter upon iterating elements.
Represents the contents of a folder as class files.
Represents a jar file as a source.
A source that represents a collection of in-memory resources that are represented as byte arrays.
An iterator that represents map entries as sources.
An origin for elements.
An origin that forwards all invocations to a delegate where an
ElementMatcher is applied prior to iteration.An iterator that applies a filter to observed elements.
An origin implementation for a jar file.
A summary of the application of a
Plugin.Engine to a source and target.A target for a plugin engine represents a sink container for all elements that are supplied by a
Plugin.Engine.Source.A sink that discards any entry.
Represents a folder as the target for a plugin engine's application.
Represents a jar file as a target.
A sink that stores all elements in a memory map.
A sink represents an active writing process.
Implements a sink for a jar file.
A type strategy determines the transformation that is applied to a type description.
Default implementations for type strategies.
A type strategy that represents a given
EntryPoint for a build tool.A factory for providing a build plugin.
A simple factory that returns a preconstructed plugin instance..
A plugin factory that uses reflection for instantiating a plugin.
Allows to resolve arguments for a
Plugin constructor.An argument resolver that resolves an argument for a specific parameter index.
An argument resolver that resolves an argument for a specific parameter index by attempting a conversion via
invoking a static
valueOf method on the target type, if it exists.An argument resolver that resolves parameters for a given type.
An argument resolver that never resolves an argument.
A resolution provided by an argument provider.
Represents a resolved argument resolution.
Represents an unresolved argument resolution.
An instantiator is responsible for invoking a plugin constructor reflectively.
Represents an ambiguously resolved instantiator.
An instantiator that is resolved for a given constructor with arguments.
An instantiator that is not resolved for creating an instance.
Indicates that a constructor should be treated with a given priority if several constructors can be resolved.
An abstract base for a
Plugin that matches types by a given ElementMatcher.A non-operational plugin that does not instrument any type.
A plugin that applies a preprocessor, i.e.
Describes an argument to a
Plugin constructor.This delegate is responsible for boxing a primitive types to their wrapper equivalents.
This assigner is able to handle non-
void, primitive types.Matches a primitive type.
This delegate is responsible for unboxing a wrapper type to their primitive equivalents.
An explicitly types unboxing responsible is applied for directly unboxing a wrapper type.
An unboxing responsible for an implicitly typed value.
Implementations represent an unboxing delegate that is able to perform the unboxing operation.
This delegate is responsible for widening a primitive type to represent a larger primitive type.
A stack manipulation that widens a primitive type into a more general primitive type.
A
PrivilegedExceptionAction to lookup a method constant using an java.security.AccessController.Describes if a method parameter is mandated, i.e.
A factory for creating a
Queue.A dispatcher for creating an
java.util.ArrayDeque.A provider of randomized
String values.A type builder that rebases an instrumented type.
An implementation target for redefining a given type while preserving the original methods within the
instrumented type.
A factory for creating a
RebaseImplementationTarget.A
Implementation.SpecialMethodInvocation which invokes a rebased method
as given by a MethodRebaseResolver.An appender that writes attributes or annotations to a given ASM
RecordComponentVisitor.A record component attribute appender that combines several method attribute appenders to be represented as a single
record component attribute appender.
Appends an annotation to a record component.
A factory that creates record component attribute appenders for a given type.
A record component attribute appender factory that combines several record component attribute appender factories to be
represented as a single factory.
An attribute appender that writes all annotations that are declared on a record component.
A record component attribute appender that does not append any attributes.
Represents a component of a Java record.
An abstract base implementation for a record component description.
Represents a loaded record component.
A dispatcher for accessing methods of
java.lang.reflect.RecordComponent.A description of a record component in its defined shape.
An abstract base implementation of a record component description in its defined shape.
A description of a record component in generic shape.
A latent record component description.
A token representing a record component's properties detached from a type.
A type substituting representation of a record component description.
Implementations represent a list of record component descriptions.
An abstract base implementation of a list of record components.
An empty list of record components.
A wrapper implementation of an explicit list of record components.
A list of loaded record components.
A list of record components described as tokens.
A type-substituting list of record component descriptions.
A record component registry represents an extendable collection of record components which are identified by their names that are mapped
to a given
RecordComponentAttributeAppender.Represents a compiled record component registry.
A no-op record component registry that does not register annotations for any record component.
An immutable default implementation of a record component registry.
A compiled default record component registry.
An entry of a compiled record component registry.
An entry of the default record component registry.
Matches a record.
A type builder that redefines an instrumented type.
A simple assigner that is capable of handling the casting of reference types.
A stack manipulation that computes the remainder two numbers on the operand stack.
Removes a value from the operand stack.
A plugin that allows for adding a
java.lang.annotation.Repeatable annotation even if compiled prior to
Java 8 which introduces this annotation.Indicates that the annotated annotation should be repeatable by the supplied annotation.
A type attribute appender that adds a repeated annotation for a target type.
A class file transformer that can reset its transformation.
An abstract base implementation of a
ResettableClassFileTransformer.Implements a resettable class file transformer that allows for the delegation of a transformation.
Parameters that are annotated with this annotation will be assigned by also considering the runtime type of the
target parameter.
A non-instantiable type that allows to check if a method or parameter should consider a runtime type.
A constant that represents a value in its serialized form.
An action for making an
AccessibleObject accessible.A stack manipulation that shifts left two numbers on the operand stack.
A stack manipulation that shifts right two numbers on the operand stack.
A stack manipulation that shifts right unsigned two numbers on the operand stack.
Matches a method description's signature token against another matcher.
A method visitor that is aware of the current size of the operand stack at all times.
Describes a manipulation of a method's operand stack that does not affect the frame's variable array.
An abstract base implementation of a valid stack manipulation.
An immutable stack manipulation that aggregates a sequence of other stack manipulations.
Canonical representation of an illegal stack manipulation.
An implementation of
StackManipulation that simplifies functional invocations via lambda expressions.A dispatcher for an instance of
StackManipulation.Simple.A description of the size change that is imposed by some
StackManipulation.Canonical representation of a legal stack manipulation which does not require any action.
Represents the size of a Java type on the operand stack.
A utility for draining the contents of an
InputStream into a byte array.An element matcher that compares two strings by a given pattern which is characterized by a
StringMatcher.Mode.Defines the mode a
StringMatcher compares to strings with.An element matcher which checks if a string is in a set of strings.
This implementation creates a method stub which does nothing but returning the default value of the return
type of the method.
A stub value represents the (boxed) default value of the intercepted method's return type.
Binds the
StubValue annotation.A type builder that creates an instrumented type as a subclass, i.e.
A matcher that locates all methods that are overridable and not ignored or that are directly defined on the instrumented type.
An implementation target for creating a subclass of a given type.
A factory for creating a
SubclassImplementationTarget.Responsible for identifying the origin type that an implementation target represents when
Implementation.Target.getOriginType() is invoked.A stack manipulation that subtracts two numbers on the operand stack.
An element matcher that matches its argument for being another type's subtype.
Parameters that are annotated with this annotation are assigned an instance of an auxiliary proxy type that allows calling
any
super methods of the instrumented type where the parameter type must be a super type of the instrumented type.A binder for handling the
Super
annotation.Locates the type which should be the base type of the created proxy.
A type locator that yields the instrumented type.
A type locator that yields the target parameter's type.
A type locator that returns a given type.
Determines the instantiation of the proxy type.
Parameters that are annotated with this annotation will be assigned a proxy for calling the instrumented method's
super implementation.A binder for handling the
SuperCall
annotation.A parameter with this annotation is assigned an instance of
Method which invokes the super implementation of this method.A binder for the
SuperMethod annotation.Loads the delegation method constant onto the stack.
This implementation will create a new method which simply calls its super method.
An appender for implementing a
SuperMethodCall.A handler that determines how to handle the method return value.
A super method invocation where the return value is dropped instead of returning from the method.
An element matcher that matches its argument for being another type's super type.
Describes if a method is supposed to be synchronized.
Defines if a type or member is supposed to be marked as synthetic.
This
MethodDelegationBinder binds
method by analyzing annotations found on the target method that is subject to a method binding.A delegation processor is a helper class for a
TargetMethodAnnotationDrivenBinder
for performing its actual logic.A handler is responsible for processing a parameter's binding.
A bound handler represents an unambiguous parameter binder that was located for a given array of
annotations.
An unbound handler is a fallback for returning an illegal binding for parameters for which no parameter
binder could be located.
A default implementation of an
Argument annotation.A parameter binder is used as a delegate for binding a parameter according to a particular annotation type found
on this parameter.
A parameter binder that binds a field's value.
Implements a parameter binder that binds a fixed value to a parameter with a given annotation.
A parameter binder that binds a fixed value to a parameter annotation when using a
MethodDelegation.A compiled record of a target method annotation-driven binder.
This type is used as a place holder for creating methods or fields that refer to the type that currently subject
of creation within a
DynamicType.Builder.Represents a
String value that is stored in a type's constant pool.
Parameters that are annotated with this annotation will be assigned a reference to the instrumented object, if
the instrumented method is not static.
A binder for handling the
This
annotation.Throws a
Throwable which must lie on top of the stack when this stack manipulation is called.An implementation of
Object.toString() that concatenates the String representation of all fields that are declared by a class.An appender to implement
ToStringMethod.A prefix resolver is responsible for providing a value that is prepended to a
Object.toString() implementation.Default implementations for a prefix resolver.
A prefix resolver that returns a fixed value.
A value consumer that is responsible for adding a field value to the string creating
StringBuilder.A build tool plugin that adds a
Object.toString() and method to a class if the ToStringPlugin.Enhance annotation is present and no
explicit method declaration was added.Instructs the
ToStringPlugin to generate a Object.toString() method for the annotated class unless this method
is already declared explicitly.A strategy for defining a prefix.
Determines that the annotated field is excluded from a string representation of the
ToStringPlugin.A transformation specification to apply during the plugin's execution.
A transformer is responsible for transforming an object into a compatible instance of the same type.
A compound transformer.
A transformer for a field that delegates to another transformer that transforms a
FieldDescription.Token.A transformer for a field's modifiers.
An implementation of a transformed field.
A transformer for a field that delegates to another transformer that transforms a
MethodDescription.Token.A transformer for a method's modifiers.
The transformed method.
A non-operational transformer that returns the received instance.
A trivial type that extends
Object without defining any fields, methods or constructors.An appender that writes attributes or annotations to a given ASM
ClassVisitor.A compound type attribute appender that concatenates a number of other attribute appenders.
An attribute appender that appends a single annotation to a given type.
An attribute appender that writes all annotations that are found on a given target type to the
instrumented type this type attribute appender is applied onto.
A type attribute appender that writes all annotations of the instrumented but excludes annotations up to
a given index.
A type attribute appender that does not append any attributes.
A cache for storing types without strongly referencing any class loader or type.
A key used for looking up a previously inserted class loader cache.
A simple key based on a collection of types where no type is strongly referenced.
Determines the storage format for a cached type.
A key used for storing a class loader cache reference.
An implementation of a
TypeCache where obsolete references are cleared upon any call.A stack manipulation for a type down casting.
This class visitor wrapper ensures that class files of a version previous to Java 5 do not store class entries in the generated class's constant pool.
A class visitor that checks a class file version for its support of storing class constants in the constant pool and remaps such constants
on discovery if that is not the case.
A method visitor that remaps class constants to invocations of
Class.forName(String).A stack manipulation for creating an undefined type on which a constructor is to be called.
Implementations define a type, either as a
TypeDescription or as a TypeDescription.Generic.Represents a
TypeDescription.Generic's form.A proxy for interacting with
java.lang.reflect.AnnotatedType.An iterator that iterates over a type's class hierarchy.
Implementations of this interface represent a Java type, i.e.
An abstract base implementation of a type description.
An adapter implementation of a
TypeDescription that
describes any type that is not an array or a primitive type.An implementation of a type description that delegates all properties but the type's name to a delegate.
A projection for an array type based on an existing
TypeDescription.A type description implementation that represents a loaded type.
A dispatcher for using methods of
Class that are not declared for Java 6.A type representation of a package description.
Represents a generic type of the Java programming language.
An abstract base implementation of a generic type description.
An annotation reader is responsible for lazily evaluating type annotations if this language
feature is available on the current JVM.
A delegating annotation reader that delegates all invocations to an annotation reader that wraps the previous one.
A chained delegator that bases its result on an underlying annotation reader.
A delegating annotation reader for an annotated exception variable.
A proxy type for interacting with
java.lang.reflect.Executable.A delegating annotation reader for an annotated parameter variable.
A type for interacting with
java.lang.reflect.Executable.A delegating annotation reader for an annotated field variable.
A dispatcher for interacting with
Field.A delegating annotation reader for an annotated interface type.
A delegating annotation reader for an annotated return variable.
A dispatcher for interacting with
Method.An annotation reader for a
java.lang.reflect.RecordComponent.A delegating annotation reader for an annotated super type.
A delegating annotation reader for an annotated type variable.
A simple delegator for a given
AnnotatedElement.A chained annotation reader for reading a component type.
A proxy to interact with
java.lang.reflect.AnnotatedArrayType.A chained annotation reader for reading an owner type.
A proxy to interact with
java.lang.reflect.AnnotatedType.A chained annotation reader for reading a parameterized type's type argument.
A proxy to interact with
java.lang.reflect.AnnotatedParameterizedType.A chained annotation reader for reading a type variable's type argument.
A proxy to interact with
java.lang.reflect.AnnotatedTypeVariable.A chained annotation reader for reading a formal type variable's type argument.
A proxy to interact with
java.lang.reflect.TypeVariable.A chained annotation reader for reading a wildcard type's lower bound type.
A proxy to interact with
java.lang.reflect.AnnotatedWildcardType.A chained annotation reader for reading a wildcard type's upper bound type.
A proxy to interact with
java.lang.reflect.AnnotatedWildcardType.A non-operational annotation reader.
A builder for creating describing a generic type as a
TypeDescription.Generic.A generic type builder building a generic array type.
A generic type builder for building a non-generic type.
A generic type builder for building a parameterized type.
A generic type builder building a symbolic type variable.
A visitor to resolve a generic type to a
TypeDescription.Generic.Builder.A lazy projection of a generic type.
A lazy projection of a field's type.
A lazy projection of a method's generic return type.
A lazy projection of a generic super type.
A lazy projection of the parameter type of a
Constructor.A lazy projection of the parameter type of a
Method.A lazy projection of a
java.lang.reflect.RecordComponent's type.A lazy projection of a type that resolves super class and interface types eagerly.
A description of an annotated lazy type with eager navigation.
A lazy projection of a type with a lazy resolution of super class and interface types.
A lazy representation of a lazy projection's interfaces.
A lazy interface type description for a lazy projection.
A lazy super class description for a lazy projection.
A description of an annotated lazy type with lazy navigation.
A lazy projection that applies a visitor only when resolving the generic type but not when reading the erasure.
A base implementation of a generic type description that represents a potentially generic array.
A description of a loaded generic array type.
A latent implementation of a generic array type.
A raw type representation of a non-generic type.
A type description for a type erasure.
Represents a non-generic type for a loaded
Class.A representation of a raw type that preserves its generic super types' generic information with a minimum
but erases all of their members' types.
A latent description of a non-generic type.
A base implementation of a generic type description that represents a parameterized type.
Represents an erasure as a generic type where all type variables are representing their own arguments.
Description of a loaded parameterized type.
A type list that represents a loaded parameterized type's parameter types.
A representation of a parameterized type that is a super type of a raw type but preserves the minimal type information
that is required for allowing creating correct erasures for overridden methods.
A latent description of a parameterized type.
A rendering delegate for resolving a parameterized type's
Object.toString() representation.A base implementation of a generic type description that represents a type variable.
Description of a loaded type variable.
A list of type variable bounds for a loaded
TypeVariable that resolves annotations..Implementation of a symbolic type variable.
A type variable with explicit annotations that replace the annotations that are declared by the provided type variable.
A base implementation of a generic type description that represents a wildcard type.
Description of a loaded wildcard.
A type list representing an upper-bound type variable's bound types.
A type list representing an upper-bound type variable's bound types.
A latent description of a wildcard type.
A visitor that can be applied to a
TypeDescription.Generic for differentiating on the sort of the visited type.A visitor that strips all type annotations of all types.
Representation of a type variable without annotations.
A visitor that determines the direct assignability of a type to another generic type.
A dispatcher that allows to check if the visited generic type is assignable to the supplied type.
An abstract base implementation of a dispatcher that forwards the decision to a visitor implementation.
A dispatcher for checking the assignability of a generic array type.
A dispatcher for checking the assignability of a non-generic type.
A dispatcher for checking the assignability of a parameterized type.
An assigner for a parameter of a parameterized type.
A dispatcher for an contravariant parameter of a parameterized type, i.e.
A dispatcher for an covariant parameter of a parameterized type, i.e.
A dispatcher for an invariant parameter of a parameterized type, i.e.
A dispatcher for checking the assignability of a type variable.
A visitor that transforms any type into a raw type if declaring type is generified.
Visits a generic type and appends the discovered type to the supplied signature visitor.
Visits a parameter while visiting a generic type for delegating discoveries to a signature visitor.
A non-operational generic type visitor.
A visitor that reduces a detached generic type to its erasure.
A visitor that reifies type descriptions if they represent raw types.
An abstract implementation of a visitor that substitutes generic types by replacing (nested)
type variables and/or non-generic component types.
A substitutor that attaches type variables to a type variable source and replaces representations of
TargetType with a given declaring type.A visitor for detaching a type from its declaration context by detaching type variables.
A substitutor that replaces a type description with an equal type description.
A substitutor that normalizes a token to represent all
TargetType by a given type and that symbolizes all type variables.A visitor for binding type variables to their values.
A
TypeDescription.Generic.Visitor.Substitutor that only substitutes type variables but fully preserves non-generic type definitions.A visitor that returns the erasure of any visited type.
A validator for Java types that are defined for a specified type use within a Java class file.
A type validator for checking type annotations.
A latent type description for a type without methods or fields.
A delegating type description that always attempts to load the super types of a delegate type.
A class loading delegate is responsible for resolving a type given a class loader and a type name.
A simple class loading delegate that simply loads a type.
A type list that attempts loading any type.
A type projection that attempts to load any super type of the delegate type.
A type initializer is responsible for defining a type's static initialization block.
A drain for writing a type initializer.
A default implementation of a type initializer drain that creates a initializer method.
Canonical implementation of a non-defined type initializer.
A simple, defined type initializer that executes a given
ByteCodeAppender.Implementations represent a list of type descriptions.
An abstract base implementation of a type list.
An implementation of an empty type list.
A wrapper implementation of an explicit list of types.
Implementation of a type list for an array of loaded types.
A list containing descriptions of generic types.
An abstract base implementation of a generic type list.
An empty list of generic types.
An explicit list of generic types.
A list of detached types that are attached on reception.
A list of attached type variables represented by a list of type variable tokens.
A wrapper for representing a type variable in its attached state.
A list of detached types that are attached on reception but not when computing an erasure.
A list of loaded generic types.
A type list that represents loaded type variables.
A lazy projection of a constructor's exception types.
A projection of a specific exception type.
A lazy projection of a type's generic interface types.
A type projection of an interface type.
A lazy projection of a method's exception types.
A projection of a specific exception type.
Describes a type's manifestation, i.e.
A type pool allows the retrieval of
TypeDescription by its name.A base implementation of a
TypePool that is managing a cache provider and
that handles the description of array and primitive types.A resolution for a type that, if resolved, represents an array type.
A lazy representation of the component type of an array.
Implements a hierarchical view of type pools, similarly to class loader hierarchies.
A cache provider for a
TypePool.A discriminating cache provider that delegates a type name to one of two caches.
A non-operational cache that does not store any type descriptions.
A simple, thread-safe type cache based on a
ConcurrentHashMap.A
TypePool.CacheProvider.Simple cache provider that clears its storage if the heap is filled, by using a soft reference.A type pool that attempts to load a class.
A default implementation of a
TypePool that models binary data in the Java byte code format
into a TypeDescription.An annotation registrant implements a visitor pattern for reading an unknown amount of values of annotations.
An abstract base implementation of an annotation registrant.
A base implementation for a collector for a type variable.
A base implementation for a collector for a type variable with an index.
A base implementation for a collector for a type variable with two indices.
An annotation collector for a byte code element.
An annotation collector for a byte code element with an index.
An annotation collector for a type variable.
An annotation collector for a type variable with an index.
An annotation collector for a type variable with two indices.
A component type locator allows for the lazy location of an array's component type.
A component type locator that lazily analyses an annotation for resolving an annotation property's
array value's component type.
A component type locator that locates an array type by a method's return value from its method descriptor.
A component type locator which cannot legally resolve an array's component type.
A generic type extractor allows for an iterative extraction of generic type information.
TypePool.Default.GenericTypeExtractor.ForSignature<T extends TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution>
A signature visitor for extracting a generic type resolution.
A parser for a generic field signature.
A parser for a generic method signature.
A parser for a generic field signature.
A parser for a generic type signature.
An incomplete
TypePool.Default.LazyTypeDescription.GenericTypeToken.An abstract base implementation of an incomplete token.
An incomplete generic type token representing a type with an outer type.
An incomplete token representing a generic type without an outer type.
A type registrant allows to register a generic type token.
A signature visitor that rejects any discovered generic type.
A type description that looks up any referenced
ByteCodeElement or
AnnotationDescription by querying a type pool at lookup time.A token for representing collected data on an annotation.
A resolution for an annotation tokens.
An illegal resolution.
A simple resolved annotation.
A token for representing collected data on a field.
A token that represents a generic Java type.
A generic type token that represents a generic array.
A generic type representation of a generic array.
A generic type token for a wildcard that is bound below.
A generic type representation of a lower bound wildcard.
A generic type token that represents a parameterized type.
A generic type description that represents a parameterized type without an enclosing generic owner type.
A generic type token to describe a parameterized type description with a generic owner type.
A lazy description of a parameterized type with an owner type.
A generic type token that represents a primitive type.
A representation of a lazy primitive type.
A generic type token that represents a non-generic type.
A generic type token that represents a type variable.
An annotated representation of a formal type variable.
A generic type token that represent a formal type variable, i.e.
A type description that represents a type variable with bounds that are resolved lazily.
A list representing a formal type variable's bounds.
Represents a type variable that a type references but that does not exist.
A generic type token that represents an unbound wildcard.
A generic type representation of a generic unbound wildcard.
A generic type token for a wildcard that is bound above.
A generic type representation of a tokenized wildcard with an upper bound.
A lazy list of type tokens.
A generic type description representing a tokenized wildcard bound.
Represents a generic type token for a formal type variable.
A resolution of a type's, method's or field's generic types.
A resolution of the generic type of a
FieldDescription.An implementation of a tokenized resolution of the generic type of a
FieldDescription.A resolution of the generic types of a
MethodDescription.An implementation of a tokenized resolution of generic types of a
MethodDescription.A resolution of the generic type of a
RecordComponentDescription.An implementation of a tokenized resolution of the generic type of a
RecordComponentDescription.A resolution of the generic types of a
TypeDescription.An implementation of a tokenized resolution of generic types of a
TypeDescription.A resolution of a type's, method's or field's generic types if its generic signature is malformed.
A resolution of a type's, method's or field's generic types if all of the represented element's are raw.
Represents a non-generic type that defines type annotations.
A generic type list representing raw types.
A lazy description of an annotation that looks up types from a type pool when required.
A loadable version of a lazy annotation description.
A proxy for a lazy annotation value.
A lazy annotation value description for an annotation value.
A lazy projection of an annotation value that contains an array of values.
A lazy annotation value description for an enumeration value.
A proxy for a mismatched type for which the property is not yet know.
A lazy annotation value description for a type value.
A lazy list that represents all nest members of the represented type.
An implementation of a
PackageDescription that only
loads its annotations on requirement.A list that is constructing
TypePool.Default.LazyTypeDescriptions.A token for representing collected data on a method.
A token representing a method's parameter.
A token representing a record component.
A representation of a generic type that is described by a
TypePool.Default.LazyTypeDescription.GenericTypeToken.A lazy description of a non-well-defined described generic type.
A tokenized list of non-well-defined generic types.
A tokenized list of generic types.
A list of tokenized type variables.
A declaration context encapsulates information about whether a type was declared within another type
or within a method of another type.
Describes a type that is not contained within another type, a method or a constructor.
Describes a type that is contained within a method or constructor.
Describes a type that is contained within another type.
A bag for collecting parameter meta information that is stored as debug information for implemented
methods.
Determines the granularity of the class file parsing that is conducted by a
TypePool.Default.
A variant of
TypePool.Default that resolves type descriptions lazily.An empty type pool that cannot describe any type.
A type pool that supplies explicitly known type descriptions.
A lazy facade of a type pool that delegates any lookups to another type pool only if another value than the type's name is looked up.
The lazy resolution for a lazy facade for a type pool.
A description of a type that delegates to another type pool once a property that is not the name is resolved.
A resolution of a
TypePool which was queried for a description.A canonical representation of a non-successful resolution of a
TypePool.An exception that indicates that a
TypePool could not resolve a TypeDescription for a given name.A simple resolution that represents a given
TypeDescription.A type proxy creates accessor methods for all overridable methods of a given type by subclassing the given type and
delegating all method calls to accessor methods of the instrumented type it was created for.
A stack manipulation that throws an abstract method error in case that a given super method cannot be invoked.
Creates a type proxy which delegates its super method calls to any invokable default method of
a given interface and loads an instance of this proxy onto the operand stack.
Loads a type proxy onto the operand stack which is created by calling one of its constructors.
Loads a type proxy onto the operand stack which is created by constructing a serialization constructor using
the Oracle JDK's
ReflectionFactory.newConstructorForSerialization(Class, java.lang.reflect.Constructor)
method which might not be available in any Java runtime.An invocation factory is responsible for creating a special method invocation for any method that is to be
invoked.
Default implementations of the
TypeProxy.InvocationFactory.An implementation of a silent construction of a given type by using the non-standardized
ReflectionFactory.The appender for implementing a
TypeProxy.SilentConstruction.Adds an attribute value for all inner classes that are referenced by the instrumented type.
A class visitor that collects all type references and all inner class references.
A type resolution strategy is responsible for loading a class and for initializing its
LoadedTypeInitializers.A type resolution strategy that applies all
LoadedTypeInitializer as a part of class loading using reflection.A resolved version of an active type resolution strategy.
A type resolution strategy that does not allow for explicit loading of a class and that does not inject any code into the type initializer.
A type resolution strategy that does not apply any
LoadedTypeInitializers but only loads all types.A type resolution strategy that applies all
LoadedTypeInitializer after class loading using reflection.A resolved
TypeResolutionStrategy.An element matcher that validates that a given generic type description represents a type of a given name.
If type validation is enabled, Byte Buddy performs several checks to ensure that a generated
class file is specified in a valid manner.
A type variable source represents a code element that can declare type variables.
An abstract base implementation of a type variable source.
A visitor that can be applied to a type variable source.
A none-operational implementation of a type variable visitor that simply returns the visited source.
A tokenized representation of a type variable.
A type writer is a utility for writing an actual class file using the ASM library.
A default implementation of a
TypeWriter.An action to write a class file to the dumping location.
A dispatcher for dumping class files to the file system.
A disabled dispatcher that does not dump any class files.
An enabled dispatcher that dumps class files to a given folder.
A type writer that creates a class file that is not based upon another, existing class.
A type writer that inlines the created type into an existing class file.
A context registry allows to extract auxiliary types from a lazily created implementation context.
A default type writer that only applies a type decoration.
A field list that only reads fields lazy to avoid an eager lookup since fields are often not required.
A default type writer that reprocesses a type completely.
An initialization handler is responsible for handling the creation of the type initializer.
An initialization handler that appends code to a previously visited type initializer.
A frame writer is responsible for adding empty frames on jump instructions.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.FrameWriter.Active
An active frame writer that creates the most efficient frame.
A frame writer that creates an expanded frame.
A non-operational frame writer.
An initialization handler that appends code to a previously visited type initializer with allowing active
TypeInitializer registrations.A code appending initialization handler with a drain that applies an explicit record.
A code appending initialization handler with a drain that does not apply an explicit record.
An initialization handler that appends code to a previously visited type initializer without allowing active
TypeInitializer registrations.An initialization handler that appends code to a previously visited type initializer without allowing active
TypeInitializer registrations and with an active record.An initialization handler that appends code to a previously visited type initializer without allowing active
TypeInitializer registrations and without an active record.An initialization handler that creates a new type initializer.
A
ClassRemapper that uses the Byte Buddy-defined API version.A key to represent a unique signature.
A class validator that validates that a class only defines members that are appropriate for the sort of the generated class.
A constraint for members that are legal for a given type.
A constraint implementation that summarizes several constraints.
Represents the constraint of an annotation type.
Represents the constraint of a class type.
Represents the constraint implied by a class file version.
Represents the constraint of an interface type.
Represents the constraint of a package type.
Represents the constraint of a record type.
An field pool that allows a lookup for how to implement a field.
A field pool that does not allow any look ups.
An entry of a field pool that describes how a field is implemented.
A record for a rich field with attributes and a potential default value.
A record for a simple field without a default value where all of the field's declared annotations are appended.
An method pool that allows a lookup for how to implement a method.
An entry of a method pool that describes how a method is implemented.
A wrapper that appends accessor bridges for a method's implementation.
A method representing an accessor bridge method.
A method representing a bridge's target method in its defined shape.
A base implementation of an abstract entry that defines a method.
A record for a visibility bridge.
A method describing a visibility bridge.
Describes an entry that defines a method with a default annotation value.
Describes an entry that defines a method as byte code.
Describes an entry that defines a method but without byte code and without an annotation value.
A canonical implementation of a method that is not declared but inherited by the instrumented type.
The sort of an entry.
An record component pool that allows a lookup for how to implement a record component.
A record component pool that does not allow any look ups.
An entry of a record component pool that describes how a record component is implemented.
A record for a rich record component with attributes.
A record for a simple field without a default value where all of the record component's declared annotations are appended.
Indicates that a field, method or parameter is undefined for its usage
null.Indicates that a field, method or parameter is undefined for its usage
null.
An implementation for attachment on a virtual machine.
An abstract base implementation for a virtual machine.
A virtual machine attachment implementation for a HotSpot VM or any compatible JVM.
Represents a connection to a virtual machine.
A factory for creating connections to virtual machines.
A factory for attaching via a socket file.
A connection that is represented by a byte channel that is persistent during communication.
A response to an execution command to a VM.
A resolver for the current VM's virtual machine attachment emulation.
Describes a type's, field's or a method's visibility.
Implements a strategy for deciding if a visibility bridge should be generated.
Default implementations of visibility bridge strategies.
An element matcher that validates that a given byte code element is visible to a given type.
This assigner is able to handle the
void type.
NamingStrategy.Suffixing.BaseNameResolver.