All Classes

Class	Description
AbstractInliningDynamicTypeBuilder<T>	An abstract base implementation of a dynamic type builder that alters an existing type.
AccessibilityMatcher<T extends ByteCodeElement>	An element matcher that validates that a given byte code element is accessible to a given type.
Addition	A stack manipulation that adds to numbers on the operand stack.
Advice	Advice wrappers copy the code of blueprint methods to be executed before and/or after a matched method.
Advice.AdviceVisitor	A method visitor that weaves the advice methods' byte codes.
Advice.AdviceVisitor.WithExitAdvice	An advice visitor that applies exit advice.
Advice.AdviceVisitor.WithExitAdvice.WithExceptionHandling	An advice visitor that captures exceptions by weaving try-catch blocks around user code.
Advice.AdviceVisitor.WithExitAdvice.WithoutExceptionHandling	An advice visitor that does not capture exceptions.
Advice.AdviceVisitor.WithoutExitAdvice	An advice visitor that does not apply exit advice.
Advice.AllArguments	Assigns an array containing all arguments of the instrumented method to the annotated parameter.
Advice.Appender	A byte code appender for implementing Advice.
Advice.Appender.EmulatingMethodVisitor	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.
Advice.Argument	Indicates that the annotated parameter should be mapped to the parameter with index Advice.Argument.value() of the instrumented method.
Advice.ArgumentHandler	An argument handler is responsible for resolving offsets of the local variable array in the context of the applied instrumentation.
Advice.ArgumentHandler.Factory	A factory for creating an argument handler.
Advice.ArgumentHandler.ForAdvice	An argument handler that is used for resolving an advice method.
Advice.ArgumentHandler.ForAdvice.Default	A default implementation for an argument handler for an advice method.
Advice.ArgumentHandler.ForAdvice.Default.ForMethodEnter	An argument handler for an enter advice method.
Advice.ArgumentHandler.ForAdvice.Default.ForMethodExit	An argument handler for an exit advice method.
Advice.ArgumentHandler.ForInstrumentedMethod	An argument handler that is used for resolving the instrumented method.
Advice.ArgumentHandler.ForInstrumentedMethod.Default	A default implementation of an argument handler for an instrumented method.
Advice.ArgumentHandler.ForInstrumentedMethod.Default.Copying	An argument handler for an instrumented method that copies all arguments before executing the instrumented method.
Advice.ArgumentHandler.ForInstrumentedMethod.Default.Simple	A simple argument handler for an instrumented method.
Advice.Delegator	Materializes an advice invocation within a delegation.
Advice.Delegator.ForDynamicInvocation	Invokes an advice method using a dynamic method call.
Advice.Delegator.ForStaticInvocation	Invokes an advice method using a static method call.
Advice.Dispatcher	A dispatcher for implementing advice.
Advice.Dispatcher.Bound	A bound resolution of an advice method.
Advice.Dispatcher.Delegating	A dispatcher for an advice method that is being invoked from the instrumented method.
Advice.Dispatcher.Delegating.Resolved	A resolved version of a dispatcher.
Advice.Dispatcher.Delegating.Resolved.AdviceMethodWriter	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.
Advice.Dispatcher.Delegating.Resolved.AdviceMethodWriter.ForMethodEnter	An advice method writer for a method enter.
Advice.Dispatcher.Delegating.Resolved.AdviceMethodWriter.ForMethodExit	An advice method writer for a method exit.
Advice.Dispatcher.Delegating.Resolved.ForMethodEnter	A resolved dispatcher for implementing method enter advice.
Advice.Dispatcher.Delegating.Resolved.ForMethodEnter.WithDiscardedEnterType	Implementation of an advice that does not expose an enter type.
Advice.Dispatcher.Delegating.Resolved.ForMethodEnter.WithRetainedEnterType	Implementation of an advice that does expose an enter type.
Advice.Dispatcher.Delegating.Resolved.ForMethodExit	A resolved dispatcher for implementing method exit advice.
Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithExceptionHandler	Implementation of exit advice that handles exceptions.
Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithoutExceptionHandler	Implementation of exit advice that ignores exceptions.
Advice.Dispatcher.Inactive	An implementation for inactive devise that does not write any byte code.
Advice.Dispatcher.Inlining	A dispatcher for an advice method that is being inlined into the instrumented method.
Advice.Dispatcher.Inlining.CodeTranslationVisitor	A visitor for translating an advice method's byte code for inlining into the instrumented method.
Advice.Dispatcher.Inlining.Resolved	A resolved version of a dispatcher.
Advice.Dispatcher.Inlining.Resolved.ForMethodEnter	A resolved dispatcher for implementing method enter advice.
Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.WithDiscardedEnterType	Implementation of an advice that does not expose an enter type.
Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.WithRetainedEnterType	Implementation of an advice that does expose an enter type.
Advice.Dispatcher.Inlining.Resolved.ForMethodExit	A resolved dispatcher for implementing method exit advice.
Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithExceptionHandler	Implementation of exit advice that handles exceptions.
Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithoutExceptionHandler	Implementation of exit advice that ignores exceptions.
Advice.Dispatcher.RelocationHandler	A relocation handler is responsible for chaining the usual control flow of an instrumented method.
Advice.Dispatcher.RelocationHandler.Bound	A bound Advice.Dispatcher.RelocationHandler.
Advice.Dispatcher.RelocationHandler.Disabled	A disabled relocation handler that does never trigger a relocation.
Advice.Dispatcher.RelocationHandler.ForType	A relocation handler that is triggered if the checked value is an instance of a given type.
Advice.Dispatcher.RelocationHandler.ForValue	A relocation handler that triggers a relocation for a default or non-default value.
Advice.Dispatcher.RelocationHandler.Relocation	A relocator is responsible for triggering a relocation if a relocation handler triggers a relocating condition.
Advice.Dispatcher.RelocationHandler.Relocation.ForLabel	A relocation that unconditionally jumps to a given label.
Advice.Dispatcher.Resolved	Represents a resolved dispatcher.
Advice.Dispatcher.Resolved.AbstractBase	An abstract base implementation of a Advice.Dispatcher.Resolved dispatcher.
Advice.Dispatcher.Resolved.ForMethodEnter	Represents a resolved dispatcher for entering a method.
Advice.Dispatcher.Resolved.ForMethodExit	Represents a resolved dispatcher for exiting a method.
Advice.Dispatcher.SuppressionHandler	A suppression handler for optionally suppressing exceptions.
Advice.Dispatcher.SuppressionHandler.Bound	A bound version of a suppression handler that must not be reused.
Advice.Dispatcher.SuppressionHandler.NoOp	A non-operational suppression handler that does not suppress any method.
Advice.Dispatcher.SuppressionHandler.Suppressing	A suppression handler that suppresses a given throwable type.
Advice.Dispatcher.SuppressionHandler.Suppressing.Bound	An active, bound suppression handler.
Advice.Dispatcher.Unresolved	A dispatcher that is not yet resolved.
Advice.Enter	Indicates that the annotated parameter should be mapped to the value that is returned by the advice method that is annotated by Advice.OnMethodEnter.
Advice.ExceptionHandler	An exception handler is responsible for providing byte code for handling an exception thrown from a suppressing advice method.
Advice.ExceptionHandler.Default	Default implementations for commonly used exception handlers.
Advice.ExceptionHandler.Simple	A simple exception handler that returns a fixed stack manipulation.
Advice.Exit	Indicates that the annotated parameter should be mapped to the value that is returned by the advice method that is annotated by Advice.OnMethodExit.
Advice.FieldValue	Indicates that the annotated parameter should be mapped to a field in the scope of the instrumented method.
Advice.Local	Declares the annotated parameter as a local variable that is created by Byte Buddy for the instrumented method.
Advice.MethodSizeHandler	A handler for computing the instrumented method's size.
Advice.MethodSizeHandler.Default	A default implementation for a method size handler.
Advice.MethodSizeHandler.Default.WithCopiedArguments	A method size handler that expects that the original arguments were copied.
Advice.MethodSizeHandler.Default.WithRetainedArguments	A method size handler that expects that the original arguments are retained.
Advice.MethodSizeHandler.ForAdvice	A method size handler for an advice method.
Advice.MethodSizeHandler.ForInstrumentedMethod	A method size handler for the instrumented method.
Advice.MethodSizeHandler.NoOp	A non-operational method size handler.
Advice.NoExceptionHandler	A marker class that indicates that an advice method does not suppress any Throwable.
Advice.OffsetMapping	Represents an offset mapping for an advice method to an alternative offset.
Advice.OffsetMapping.Factory<T extends java.lang.annotation.Annotation>	Represents a factory for creating a Advice.OffsetMapping for a given parameter for a given annotation.
Advice.OffsetMapping.Factory.AdviceType	Describes the type of advice being applied.
Advice.OffsetMapping.Factory.Illegal<T extends java.lang.annotation.Annotation>	A factory for an annotation whose use is not permitted.
Advice.OffsetMapping.Factory.Simple<T extends java.lang.annotation.Annotation>	A simple factory that binds a constant offset mapping.
Advice.OffsetMapping.ForAllArguments	An offset mapping that maps an array containing all arguments of the instrumented method.
Advice.OffsetMapping.ForAllArguments.Factory	A factory for an offset mapping that maps all arguments values of the instrumented method.
Advice.OffsetMapping.ForArgument	An offset mapping for a given parameter of the instrumented method.
Advice.OffsetMapping.ForArgument.Resolved	An offset mapping for a specific parameter of the instrumented method.
Advice.OffsetMapping.ForArgument.Resolved.Factory<T extends java.lang.annotation.Annotation>	A factory for a parameter argument of the instrumented method.
Advice.OffsetMapping.ForArgument.Unresolved	An offset mapping for a parameter of the instrumented method with a specific index.
Advice.OffsetMapping.ForArgument.Unresolved.Factory	A factory for a mapping of a parameter of the instrumented method.
Advice.OffsetMapping.ForEnterValue	An offset mapping that provides access to the value that is returned by the enter advice.
Advice.OffsetMapping.ForEnterValue.Factory	A factory for creating a Advice.OffsetMapping.ForEnterValue offset mapping.
Advice.OffsetMapping.ForExitValue	An offset mapping that provides access to the value that is returned by the exit advice.
Advice.OffsetMapping.ForExitValue.Factory	A factory for creating a Advice.OffsetMapping.ForExitValue offset mapping.
Advice.OffsetMapping.ForField	An offset mapping for a field.
Advice.OffsetMapping.ForField.Resolved	A binding for an offset mapping that represents a specific field.
Advice.OffsetMapping.ForField.Resolved.Factory<T extends java.lang.annotation.Annotation>	A factory that binds a field.
Advice.OffsetMapping.ForField.Unresolved	An offset mapping for a field that is resolved from the instrumented type by its name.
Advice.OffsetMapping.ForField.Unresolved.Factory	A factory for a Advice.OffsetMapping.ForField.Unresolved offset mapping.
Advice.OffsetMapping.ForField.Unresolved.WithExplicitType	An offset mapping for a field with an explicit declaring type.
Advice.OffsetMapping.ForField.Unresolved.WithImplicitType	An offset mapping for a field with an implicit declaring type.
Advice.OffsetMapping.ForInstrumentedMethod	Maps a constant representing the instrumented method.
Advice.OffsetMapping.ForInstrumentedType	Maps the declaring type of the instrumented method.
Advice.OffsetMapping.ForLocalValue	An offset mapping that provides access to a named local variable that is declared by the advice methods via Advice.Local.
Advice.OffsetMapping.ForLocalValue.Factory	A factory for an offset mapping for a local variable that is declared by the advice methods via Advice.Local.
Advice.OffsetMapping.ForOrigin	An offset mapping for the Advice.Origin annotation.
Advice.OffsetMapping.ForOrigin.Factory	A factory for a method origin.
Advice.OffsetMapping.ForOrigin.Renderer	A renderer for an origin pattern element.
Advice.OffsetMapping.ForOrigin.Renderer.ForConstantValue	A renderer for a constant value.
Advice.OffsetMapping.ForOrigin.Renderer.ForDescriptor	A renderer for a method descriptor.
Advice.OffsetMapping.ForOrigin.Renderer.ForJavaSignature	A renderer for a method's Java signature in binary form.
Advice.OffsetMapping.ForOrigin.Renderer.ForMethodName	A renderer for a method's internal name.
Advice.OffsetMapping.ForOrigin.Renderer.ForPropertyName	A renderer for a property name.
Advice.OffsetMapping.ForOrigin.Renderer.ForReturnTypeName	A renderer for a method's return type in binary form.
Advice.OffsetMapping.ForOrigin.Renderer.ForStringRepresentation	A renderer for a method's Object.toString() representation.
Advice.OffsetMapping.ForOrigin.Renderer.ForTypeName	A renderer for a method declaring type's binary name.
Advice.OffsetMapping.ForReturnValue	An offset mapping that provides access to the value that is returned by the instrumented method.
Advice.OffsetMapping.ForReturnValue.Factory	A factory for creating a Advice.OffsetMapping.ForReturnValue offset mapping.
Advice.OffsetMapping.ForSerializedValue	An offset mapping that loads a serialized value.
Advice.OffsetMapping.ForSerializedValue.Factory<T extends java.lang.annotation.Annotation>	A factory for loading a deserialized value.
Advice.OffsetMapping.ForStackManipulation	An offset mapping for binding a stack manipulation.
Advice.OffsetMapping.ForStackManipulation.Factory<T extends java.lang.annotation.Annotation>	A factory that binds a stack manipulation.
Advice.OffsetMapping.ForStackManipulation.OfAnnotationProperty<T extends java.lang.annotation.Annotation>	A factory for binding an annotation's property.
Advice.OffsetMapping.ForStackManipulation.OfDefaultValue<T extends java.lang.annotation.Annotation>	A factory for binding the annotated parameter's default value.
Advice.OffsetMapping.ForStubValue	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.
Advice.OffsetMapping.ForThisReference	An offset mapping that provides access to the this reference of the instrumented method.
Advice.OffsetMapping.ForThisReference.Factory	A factory for creating a Advice.OffsetMapping.ForThisReference offset mapping.
Advice.OffsetMapping.ForThrowable	An offset mapping for accessing a Throwable of the instrumented method.
Advice.OffsetMapping.ForThrowable.Factory	A factory for accessing an exception that was thrown by the instrumented method.
Advice.OffsetMapping.ForUnusedValue	An offset mapping for a parameter where assignments are fully ignored and that always return the parameter type's default value.
Advice.OffsetMapping.ForUnusedValue.Factory	A factory for an offset mapping for an unused value.
Advice.OffsetMapping.Sort	Describes the sort of the executed advice.
Advice.OffsetMapping.Target	A target offset of an offset mapping.
Advice.OffsetMapping.Target.AbstractReadOnlyAdapter	An adapter class for a target that only can be read.
Advice.OffsetMapping.Target.ForArray	A target mapping for an array of all local variables.
Advice.OffsetMapping.Target.ForArray.ReadOnly	A target mapping for a read-only target mapping for an array of local variables.
Advice.OffsetMapping.Target.ForArray.ReadWrite	A target mapping for a writable target mapping for an array of local variables.
Advice.OffsetMapping.Target.ForDefaultValue	A target for an offset mapping that represents a non-operational value.
Advice.OffsetMapping.Target.ForDefaultValue.ReadOnly	A read-only target for a default value.
Advice.OffsetMapping.Target.ForDefaultValue.ReadWrite	A read-write target for a default value.
Advice.OffsetMapping.Target.ForField	A target for an offset mapping that loads a field value.
Advice.OffsetMapping.Target.ForField.ReadOnly	A read-only mapping for a field value.
Advice.OffsetMapping.Target.ForField.ReadWrite	A mapping for a writable field.
Advice.OffsetMapping.Target.ForStackManipulation	A target for an offset mapping that represents a read-only stack manipulation.
Advice.OffsetMapping.Target.ForVariable	A target for an offset mapping that represents a local variable.
Advice.OffsetMapping.Target.ForVariable.ReadOnly	A target for a read-only mapping of a local variable.
Advice.OffsetMapping.Target.ForVariable.ReadWrite	A target for a writable mapping of a local variable.
Advice.OnDefaultValue	A marker type to be used as an argument for Advice.OnMethodEnter.skipOn().
Advice.OnMethodEnter	Indicates that this method should be inlined before the matched method is invoked.
Advice.OnMethodExit	Indicates that this method should be executed before exiting the instrumented method.
Advice.OnNonDefaultValue	A marker type to be used as an argument for Advice.OnMethodEnter.skipOn().
Advice.Origin	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.
Advice.PostProcessor	A post processor for advice methods that is invoked after advice is executed.
Advice.PostProcessor.Compound	A compound post processor.
Advice.PostProcessor.Factory	A factory for creating a Advice.PostProcessor.
Advice.PostProcessor.Factory.Compound	A compound factory for a post processor.
Advice.PostProcessor.NoOp	A non-operational advice post processor.
Advice.Return	Indicates that the annotated parameter should be mapped to the return value of the instrumented method.
Advice.StackMapFrameHandler	A handler for computing and translating stack map frames.
Advice.StackMapFrameHandler.Default	A default implementation of a stack map frame handler for an instrumented method.
Advice.StackMapFrameHandler.Default.Initialization	Represents the initialization state of a stack value that can either be initialized or uninitialized.
Advice.StackMapFrameHandler.Default.TranslationMode	A translation mode that determines how the fixed frames of the instrumented method are written.
Advice.StackMapFrameHandler.Default.Trivial	A trivial stack map frame handler that applies a trivial translation for the instrumented method's stack map frames.
Advice.StackMapFrameHandler.Default.WithPreservedArguments	A stack map frame handler that requires the original arguments of the instrumented method to be preserved in their original form.
Advice.StackMapFrameHandler.Default.WithPreservedArguments.RequiringConsistentShape	A stack map frame handler that expects that the original argument frames remain preserved throughout the original invocation.
Advice.StackMapFrameHandler.Default.WithPreservedArguments.UsingArgumentCopy	A stack map frame handler that expects that an argument copy of the original method arguments was made.
Advice.StackMapFrameHandler.ForAdvice	A stack map frame handler for an advice method.
Advice.StackMapFrameHandler.ForInstrumentedMethod	A stack map frame handler for an instrumented method.
Advice.StackMapFrameHandler.NoOp	A non-operational stack map frame handler.
Advice.StubValue	Indicates that the annotated parameter should always return a default a boxed version of the instrumented methods return value (i.e.
Advice.This	Indicates that the annotated parameter should be mapped to the this reference of the instrumented method.
Advice.Thrown	Indicates that the annotated parameter should be mapped to the Throwable thrown by the instrumented method or to null if the method returned regularly.
Advice.Unused	Indicates that the annotated parameter should always return a default value (i.e.
Advice.WithCustomMapping	A builder step for creating an Advice that uses custom mappings of annotations to constant pool values.
AgentBuilder	An agent builder provides a convenience API for defining a Java agent.
AgentBuilder.CircularityLock	A circularity lock is responsible for preventing that a ClassFileLocator is used recursively.
AgentBuilder.CircularityLock.Default	A default implementation of a circularity lock.
AgentBuilder.CircularityLock.Global	A circularity lock that holds a global monitor and does not permit concurrent access.
AgentBuilder.CircularityLock.Inactive	An inactive circularity lock which is always acquirable.
AgentBuilder.ClassFileBufferStrategy	This strategy determines how the provided class file buffer is used.
AgentBuilder.ClassFileBufferStrategy.Default	An implementation of default class file buffer strategy.
AgentBuilder.Default	The default implementation of an AgentBuilder.
AgentBuilder.Default.Dispatcher	A dispatcher for interacting with the instrumentation API.
AgentBuilder.Default.Dispatcher.CreationAction	An action for creating a dispatcher.
AgentBuilder.Default.Dispatcher.ForJava6CapableVm	A dispatcher for a Java 6 capable VM.
AgentBuilder.Default.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM.
AgentBuilder.Default.ExecutingTransformer	A ClassFileTransformer that implements the enclosing agent builder's configuration.
AgentBuilder.Default.ExecutingTransformer.Factory	A factory for creating a ClassFileTransformer for the current VM.
AgentBuilder.Default.ExecutingTransformer.Factory.CreationAction	An action to create an implementation of AgentBuilder.Default.ExecutingTransformer that support Java 9 modules.
AgentBuilder.Default.ExecutingTransformer.Factory.ForJava9CapableVm	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.
AgentBuilder.Default.ExecutingTransformer.Factory.ForLegacyVm	A factory for a ClassFileTransformer on a VM that does not support the java.lang.Module API.
AgentBuilder.Default.NativeMethodStrategy	A strategy for determining if a native method name prefix should be used when rebasing methods.
AgentBuilder.Default.NativeMethodStrategy.Disabled	A native method strategy that suffixes method names with a random suffix and disables native method rebasement.
AgentBuilder.Default.NativeMethodStrategy.ForPrefix	A native method strategy that prefixes method names with a fixed value for supporting rebasing of native methods.
AgentBuilder.Default.Redefining	An implementation of a default agent builder that allows for refinement of the redefinition strategy.
AgentBuilder.Default.Transformation	A transformation to apply.
AgentBuilder.Default.Transformation.DifferentialMatcher	A matcher that considers the differential of two transformers' transformations.
AgentBuilder.Default.Transformation.SimpleMatcher	A matcher that matches any type that is touched by a transformer without being ignored.
AgentBuilder.Default.Transformation.TransformerIterator	An iterator over a list of transformations that match a raw matcher specification.
AgentBuilder.DescriptionStrategy	A description strategy is responsible for resolving a TypeDescription when transforming or retransforming/-defining a type.
AgentBuilder.DescriptionStrategy.Default	Default implementations of a AgentBuilder.DescriptionStrategy.
AgentBuilder.DescriptionStrategy.SuperTypeLoading	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.
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous	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.
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate	A class loading delegate that delegates loading of the super type to another thread.
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate.NotifyingClassLoadingAction	A class loading action that notifies the class loader's lock after the type was loaded.
AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.ThreadSwitchingClassLoadingDelegate.SimpleClassLoadingAction	A class loading action that simply loads a type.
AgentBuilder.DescriptionStrategy.SuperTypeLoading.UnlockingClassLoadingDelegate	A class loading delegate that unlocks the circularity lock during class loading.
AgentBuilder.FallbackStrategy	A fallback strategy allows to reattempt a transformation or a consideration for redefinition/retransformation in case an exception occurs.
AgentBuilder.FallbackStrategy.ByThrowableType	A fallback strategy that discriminates by the type of the Throwable that triggered a request.
AgentBuilder.FallbackStrategy.Simple	A simple fallback strategy that either always reattempts a transformation or never does so.
AgentBuilder.Identified	Describes an AgentBuilder which was handed a matcher for identifying types to instrumented in order to supply one or several AgentBuilder.Transformers.
AgentBuilder.Identified.Extendable	This interface is used to allow for optionally providing several AgentBuilder.Transformer to applied when a matcher identifies a type to be instrumented.
AgentBuilder.Identified.Narrowable	Allows to specify a type matcher for a type to instrument.
AgentBuilder.Ignored	Allows to further specify ignored types.
AgentBuilder.InitializationStrategy	An initialization strategy which determines the handling of LoadedTypeInitializers and the loading of auxiliary types.
AgentBuilder.InitializationStrategy.Dispatcher	A dispatcher for changing a class file to adapt a self-initialization strategy.
AgentBuilder.InitializationStrategy.Minimal	An initialization strategy that loads auxiliary types before loading the instrumented type.
AgentBuilder.InitializationStrategy.NoOp	A non-initializing initialization strategy.
AgentBuilder.InitializationStrategy.SelfInjection	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.
AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher	A dispatcher for a self-initialization strategy.
AgentBuilder.InitializationStrategy.SelfInjection.Dispatcher.InjectingInitializer	A type initializer that injects all auxiliary types of the instrumented type.
AgentBuilder.InitializationStrategy.SelfInjection.Eager	A form of self-injection where any auxiliary type is loaded eagerly.
AgentBuilder.InitializationStrategy.SelfInjection.Eager.Dispatcher	A dispatcher for the AgentBuilder.InitializationStrategy.SelfInjection.Eager strategy.
AgentBuilder.InitializationStrategy.SelfInjection.Lazy	A form of self-injection where any auxiliary type is loaded lazily.
AgentBuilder.InitializationStrategy.SelfInjection.Lazy.Dispatcher	A dispatcher for the AgentBuilder.InitializationStrategy.SelfInjection.Lazy strategy.
AgentBuilder.InitializationStrategy.SelfInjection.Split	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.
AgentBuilder.InitializationStrategy.SelfInjection.Split.Dispatcher	A dispatcher for the AgentBuilder.InitializationStrategy.SelfInjection.Split strategy.
AgentBuilder.InjectionStrategy	A strategy for injecting auxiliary types into a class loader.
AgentBuilder.InjectionStrategy.Disabled	An injection strategy that does not permit class injection.
AgentBuilder.InjectionStrategy.UsingInstrumentation	An injection strategy that uses bootstrap injection using an Instrumentation instance.
AgentBuilder.InjectionStrategy.UsingReflection	An injection strategy that uses Java reflection.
AgentBuilder.InjectionStrategy.UsingUnsafe	An injection strategy that uses sun.misc.Unsafe to inject classes.
AgentBuilder.InjectionStrategy.UsingUnsafe.OfFactory	An injection strategy that uses a factory for creating an unsafe injector.
AgentBuilder.InstallationListener	A listener that is notified during the installation and the resetting of a class file transformer.
AgentBuilder.InstallationListener.Adapter	An adapter implementation for an installation listener that serves as a convenience.
AgentBuilder.InstallationListener.Compound	A compound installation listener.
AgentBuilder.InstallationListener.ErrorSuppressing	A listener that suppresses any installation error.
AgentBuilder.InstallationListener.NoOp	A non-operational listener that does not do anything.
AgentBuilder.InstallationListener.StreamWriting	This installation listener prints the status of any installation to a PrintStream.
AgentBuilder.LambdaInstrumentationStrategy	Implements the instrumentation of the LambdaMetafactory if this feature is enabled.
AgentBuilder.LambdaInstrumentationStrategy.AlternativeMetaFactoryRedirection	Implements the alternative lambda meta factory.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory	A factory that creates instances that represent lambda expressions.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.BridgeMethodImplementation	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.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation	Implements a lambda class's executing transformer.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.ConstructorImplementation.Appender	An appender to implement the executing transformer.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation	An implementation of a instance factory for a lambda expression's class.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.FactoryImplementation.Appender	An appender for a lambda expression factory.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation	Implements a lambda expression's functional method.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.LambdaMethodImplementation.Appender	An appender for a lambda expression's functional method.
AgentBuilder.LambdaInstrumentationStrategy.LambdaInstanceFactory.SerializationImplementation	Implements the writeReplace method for serializable lambda expressions.
AgentBuilder.LambdaInstrumentationStrategy.MetaFactoryRedirection	Implements the regular lambda meta factory.
AgentBuilder.Listener	A listener that is informed about events that occur during an instrumentation process.
AgentBuilder.Listener.Adapter	An adapter for a listener where all methods are implemented as non-operational.
AgentBuilder.Listener.Compound	A compound listener that allows to group several listeners in one instance.
AgentBuilder.Listener.Filtering	A listener that filters types with a given name from being logged.
AgentBuilder.Listener.ModuleReadEdgeCompleting	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.
AgentBuilder.Listener.NoOp	A no-op implementation of a AgentBuilder.Listener.
AgentBuilder.Listener.StreamWriting	A listener that writes events to a PrintStream.
AgentBuilder.Listener.WithErrorsOnly	A listener that only delegates events if they are failed transformations.
AgentBuilder.Listener.WithTransformationsOnly	A listener that only delegates events if they are successful or failed transformations.
AgentBuilder.LocationStrategy	A strategy for creating a ClassFileLocator when instrumenting a type.
AgentBuilder.LocationStrategy.Compound	A compound location strategy that applies a list of location strategies.
AgentBuilder.LocationStrategy.ForClassLoader	A location strategy that locates class files by querying an instrumented type's ClassLoader.
AgentBuilder.LocationStrategy.NoOp	A location strategy that never locates any byte code.
AgentBuilder.LocationStrategy.Simple	A simple location strategy that queries a given class file locator.
AgentBuilder.Matchable<T extends AgentBuilder.Matchable<T>>	An abstraction for extending a matcher.
AgentBuilder.Matchable.AbstractBase<S extends AgentBuilder.Matchable<S>>	An abstract base implementation of a matchable.
AgentBuilder.PoolStrategy	A type locator allows to specify how TypeDescriptions are resolved by an AgentBuilder.
AgentBuilder.PoolStrategy.ClassLoading	A type locator that attempts loading a type if it cannot be located by the underlying lazy type pool.
AgentBuilder.PoolStrategy.Default	A default type locator that resolves types only if any property that is not the type's name is requested.
AgentBuilder.PoolStrategy.Eager	A type locator that resolves all type descriptions eagerly.
AgentBuilder.PoolStrategy.WithTypePoolCache	A type locator that uses type pools but allows for the configuration of a custom cache provider by class loader.
AgentBuilder.PoolStrategy.WithTypePoolCache.Simple	An implementation of a type locator AgentBuilder.PoolStrategy.WithTypePoolCache (note documentation of the linked class) that is based on a ConcurrentMap.
AgentBuilder.RawMatcher	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.
AgentBuilder.RawMatcher.Conjunction	A conjunction of two raw matchers.
AgentBuilder.RawMatcher.Disjunction	A disjunction of two raw matchers.
AgentBuilder.RawMatcher.ForElementMatchers	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.
AgentBuilder.RawMatcher.ForLoadState	A raw matcher indicating the state of a type's class loading.
AgentBuilder.RawMatcher.ForResolvableTypes	Only matches loaded types that can be fully resolved.
AgentBuilder.RawMatcher.Inversion	A raw matcher that inverts a raw matcher's result.
AgentBuilder.RawMatcher.Trivial	A matcher that always or never matches a type.
AgentBuilder.RedefinitionListenable	An agent builder configuration that allows the registration of listeners to the redefinition process.
AgentBuilder.RedefinitionListenable.WithImplicitDiscoveryStrategy	An agent builder configuration strategy that allows the definition of a discovery strategy.
AgentBuilder.RedefinitionListenable.WithoutBatchStrategy	An agent builder configuration that allows the configuration of a batching strategy.
AgentBuilder.RedefinitionStrategy	A redefinition strategy regulates how already loaded classes are modified by a built agent.
AgentBuilder.RedefinitionStrategy.BatchAllocator	A batch allocator which is responsible for applying a redefinition in a batches.
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForFixedSize	A batch allocator that creates chunks with a fixed size as batch jobs.
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForMatchedGrouping	A batch allocator that groups all batches by discriminating types using a type matcher.
AgentBuilder.RedefinitionStrategy.BatchAllocator.ForTotal	A batch allocator that includes all types in a single batch.
AgentBuilder.RedefinitionStrategy.BatchAllocator.Partitioning	A partitioning batch allocator that splits types for redefinition into a fixed amount of parts.
AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing	A slicing batch allocator that assures that any batch is within a certain size range.
AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing.SlicingIterable	An iterable that slices batches into parts of a minimum and maximum size.
AgentBuilder.RedefinitionStrategy.BatchAllocator.Slicing.SlicingIterable.SlicingIterator	An iterator that slices batches into parts of a minimum and maximum size.
AgentBuilder.RedefinitionStrategy.Collector	A collector is responsible for collecting classes that are to be considered for modification.
AgentBuilder.RedefinitionStrategy.Collector.ForRedefinition	A collector that applies a redefinition of already loaded classes.
AgentBuilder.RedefinitionStrategy.Collector.ForRetransformation	A collector that applies a retransformation of already loaded classes.
AgentBuilder.RedefinitionStrategy.Collector.PrependableIterator	An iterator that allows prepending of iterables to be applied previous to another iterator.
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy	A strategy for discovering types to redefine.
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Explicit	An explicit discovery strategy that only attempts the redefinition of specific types.
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating	A discovery strategy that considers all loaded types supplied by Instrumentation.getAllLoadedClasses().
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating.ReiteratingIterable	An iterable that returns any loaded types and checks if any additional types were loaded during the last instrumentation.
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.Reiterating.ReiteratingIterator	A reiterating iterator that considers types that were loaded during an instrumentation.
AgentBuilder.RedefinitionStrategy.DiscoveryStrategy.SinglePass	A discovery strategy that considers all loaded types supplied by Instrumentation.getAllLoadedClasses().
AgentBuilder.RedefinitionStrategy.Dispatcher	A dispatcher for interacting with the instrumentation API.
AgentBuilder.RedefinitionStrategy.Dispatcher.CreationAction	An action for creating a dispatcher.
AgentBuilder.RedefinitionStrategy.Dispatcher.ForJava6CapableVm	A dispatcher for a Java 6 capable VM.
AgentBuilder.RedefinitionStrategy.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM.
AgentBuilder.RedefinitionStrategy.Listener	A listener to be applied during a redefinition.
AgentBuilder.RedefinitionStrategy.Listener.Adapter	A listener adapter that offers non-operational implementations of all listener methods.
AgentBuilder.RedefinitionStrategy.Listener.BatchReallocator	A batch reallocator allows to split up a failed retransformation into additional batches which are reenqueed to the current retransformation process.
AgentBuilder.RedefinitionStrategy.Listener.Compound	A compound listener that delegates events to several listeners.
AgentBuilder.RedefinitionStrategy.Listener.Compound.CompoundIterable	A compound iterable.
AgentBuilder.RedefinitionStrategy.Listener.Compound.CompoundIterable.CompoundIterator	A compound iterator that combines several iterables.
AgentBuilder.RedefinitionStrategy.Listener.ErrorEscalating	A listener that halts a retransformation process upon an exception.
AgentBuilder.RedefinitionStrategy.Listener.NoOp	A non-operational listener.
AgentBuilder.RedefinitionStrategy.Listener.Pausing	A listener that invokes Thread.sleep(long) prior to every batch but the first batch.
AgentBuilder.RedefinitionStrategy.Listener.StreamWriting	A listener that writes events to a PrintStream.
AgentBuilder.RedefinitionStrategy.Listener.Yielding	A listener that invokes Thread.yield() prior to every batch but the first batch.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler	A resubmission scheduler is responsible for scheduling a job that is resubmitting unloaded types that failed during retransformation.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.AtFixedRate	A resubmission scheduler that schedules jobs at a fixed rate.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable	A cancelable allows to discontinue a resubmission job.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable.ForFuture	A cancelable for a Future.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.Cancelable.NoOp	A non-operational cancelable.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.NoOp	A resubmission scheduler that does not apply any scheduling.
AgentBuilder.RedefinitionStrategy.ResubmissionScheduler.WithFixedDelay	A resubmission scheduler that schedules jobs with a fixed delay.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy	A resubmission strategy is responsible for enabling resubmission of types that failed to resubmit.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Disabled	A disabled resubmission strategy.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled	An enabled resubmission strategy.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.LookupKey	A key for a class loader that can only be used for looking up a preexisting value but avoids reference management.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.ResubmissionInstallationListener	A job that resubmits any matched type that previously failed during transformation.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.ResubmissionListener	A listener that registers types for resubmission that failed during transformations.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.ResubmissionListener.ConcurrentHashSet<T>	A set projection for a ConcurrentHashMap.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Enabled.StorageKey	A key for a class loader that only weakly references the class loader.
AgentBuilder.RedefinitionStrategy.ResubmissionStrategy.Installation	Represents an installation of a resubmission strategy.
AgentBuilder.Transformer	A transformer allows to apply modifications to a DynamicType.
AgentBuilder.Transformer.ForAdvice	A transformer for applying an Advice where this advice class might reference types of both the agent's and the user's class loader.
AgentBuilder.Transformer.ForAdvice.Entry	An entry for an advice to apply.
AgentBuilder.Transformer.ForAdvice.Entry.ForSplitAdvice	An entry for an advice class where both entry and exit advice methods are declared by the different classes.
AgentBuilder.Transformer.ForAdvice.Entry.ForUnifiedAdvice	An entry for an advice class where both the (optional) entry and exit advice methods are declared by the same class.
AgentBuilder.Transformer.ForBuildPlugin	A transformer that applies a build Plugin.
AgentBuilder.TransformerDecorator	A decorator that allows to change the class file transformer that is registered.
AgentBuilder.TransformerDecorator.Compound	A compound transformer decorator.
AgentBuilder.TransformerDecorator.NoOp	A transformer decorator that retains the original transformer.
AgentBuilder.TypeStrategy	A type strategy is responsible for creating a type builder for a type that is being instrumented.
AgentBuilder.TypeStrategy.Default	Default implementations of type strategies.
AgentBuilder.TypeStrategy.ForBuildEntryPoint	A type strategy that applies a build EntryPoint.
AllArguments	Parameters that are annotated with this annotation will be assigned a collection (or an array) containing all arguments of the source method.
AllArguments.Assignment	A directive for how an AllArguments annotation on an array is to be interpreted.
AllArguments.Binder	A binder for handling the AllArguments annotation.
AnnotationAppender	Annotation appenders are capable of writing annotations to a specified target.
AnnotationAppender.Default	A default implementation for an annotation appender that writes annotations to a given byte consumer represented by an ASM AnnotationVisitor.
AnnotationAppender.ForTypeAnnotations	A type visitor that visits all type annotations of a generic type and writes any discovered annotation to a supplied AnnotationAppender.
AnnotationAppender.Target	Represents a target for an annotation writing process.
AnnotationAppender.Target.OnField	Target for an annotation that is written to a Java field.
AnnotationAppender.Target.OnMethod	Target for an annotation that is written to a Java method or constructor.
AnnotationAppender.Target.OnMethodParameter	Target for an annotation that is written to a Java method or constructor parameter.
AnnotationAppender.Target.OnRecordComponent	Target for an annotation that is written to a Java record component.
AnnotationAppender.Target.OnType	Target for an annotation that is written to a Java type.
AnnotationDescription	An annotation description describes Annotation meta data of a class without this class being required to be loaded.
AnnotationDescription.AbstractBase	An adapter implementation of an annotation.
AnnotationDescription.AnnotationInvocationHandler<T extends java.lang.annotation.Annotation>	An InvocationHandler for implementing annotations.
AnnotationDescription.Builder	A builder for pragmatically creating AnnotationDescription.
AnnotationDescription.ForLoadedAnnotation<S extends java.lang.annotation.Annotation>	A description of an already loaded annotation.
AnnotationDescription.Latent	A latent description of an annotation value that is defined explicitly.
AnnotationDescription.Loadable<S extends java.lang.annotation.Annotation>	An annotation description that is linked to a given loaded annotation type which allows its representation as a fully loaded instance.
AnnotationDescription.RenderingDispatcher	A rendering dispatcher is responsible for resolving annotation descriptions to String representations.
AnnotationList	Defines a list of annotation instances.
AnnotationList.AbstractBase	An abstract base implementation of an annotation list.
AnnotationList.Empty	Represents an empty annotation list.
AnnotationList.Explicit	Represents a list of explicitly provided annotation descriptions.
AnnotationList.ForLoadedAnnotations	Describes an array of loaded Annotations as an annotation list.
AnnotationRetention	An annotation retention strategy decides if annotations that are contained within a class file are preserved upon redefining or rebasing a method.
AnnotationSource	Describes a declaration source for annotations.
AnnotationSource.Empty	An annotation source that does not declare any annotations.
AnnotationSource.Explicit	An annotation source that declares a given list of annotations.
AnnotationTargetMatcher<T extends AnnotationDescription>	A matcher for annotations that target a given element type.
AnnotationTypeMatcher<T extends AnnotationDescription>	An element matcher that matches the type of an annotation description.
AnnotationValue<T,S>	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.
AnnotationValue.AbstractBase<U,V>	An abstract base implementation of an unloaded annotation value.
AnnotationValue.ForAnnotationDescription<U extends java.lang.annotation.Annotation>	A description of an Annotation as a value of another annotation.
AnnotationValue.ForAnnotationDescription.Loaded<V extends java.lang.annotation.Annotation>	A loaded version of the described annotation.
AnnotationValue.ForConstant<U>	Represents a primitive value, a String or an array of the latter types.
AnnotationValue.ForConstant.Loaded<V>	Represents a trivial loaded value.
AnnotationValue.ForConstant.PropertyDelegate	A property delegate for a constant annotation value.
AnnotationValue.ForConstant.PropertyDelegate.ForArrayType	A property delegate for an array type of a constant value.
AnnotationValue.ForConstant.PropertyDelegate.ForNonArrayType	A property delegate for a non-array type.
AnnotationValue.ForDescriptionArray<U,V>	Describes a complex array that is the value of an annotation.
AnnotationValue.ForDescriptionArray.Loaded<W>	Represents a loaded complex array.
AnnotationValue.ForEnumerationDescription<U extends java.lang.Enum<U>>	A description of an Enum as a value of an annotation.
AnnotationValue.ForEnumerationDescription.Loaded<V extends java.lang.Enum<V>>	A loaded representation of an enumeration value.
AnnotationValue.ForEnumerationDescription.Loaded.WithIncompatibleRuntimeType	Represents an annotation's enumeration value for a runtime type that is not an enumeration type.
AnnotationValue.ForEnumerationDescription.WithUnknownConstant<U extends java.lang.Enum<U>>	Represents a property with an enumeration constant that is not defined by an enumeration type.
AnnotationValue.ForEnumerationDescription.WithUnknownConstant.Loaded	Represents a property with an enumeration constant that is not defined by an enumeration type.
AnnotationValue.ForIncompatibleType<U,V>	Represents an annotation value where its declared type does not fulfil an expectation.
AnnotationValue.ForIncompatibleType.Loaded<W>	A description of annotation value for a type that does not fulfil an expectation.
AnnotationValue.ForMismatchedType<U,V>	Describes an annotation value that does not match the annotation' type for a property.
AnnotationValue.ForMismatchedType.Loaded<W>	Describes an annotation value for a property that is not assignable to it.
AnnotationValue.ForMissingType<U,V>	An annotation value for a type that could not be loaded.
AnnotationValue.ForMissingType.Loaded<U>	Represents a missing type during an annotation's resolution.
AnnotationValue.ForMissingValue<U,V>	Represents a missing annotation property which is not represented by a default value.
AnnotationValue.ForMissingValue.Loaded<W>	Describes an annotation value for a property that is not assignable to it.
AnnotationValue.ForTypeDescription<U extends java.lang.Class<U>>	A description of a Class as a value of an annotation.
AnnotationValue.ForTypeDescription.Loaded<U extends java.lang.Class<U>>	A loaded annotation value for a given type.
AnnotationValue.Loaded<U>	A loaded variant of an AnnotationValue.
AnnotationValue.Loaded.AbstractBase<W>	An abstract base implementation of a loaded annotation value.
AnnotationValue.Loaded.AbstractBase.ForUnresolvedProperty<Z>	A base implementation for an unresolved property.
AnnotationValue.RenderingDispatcher	A rendering dispatcher is responsible for resolving annotation values to String representations.
AnnotationValue.State	Represents the state of a AnnotationValue.Loaded annotation property.
AnnotationValueFilter	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.
AnnotationValueFilter.Default	A default implementation of an annotation value filter that applies the same strategy for any type, field or method.
AnnotationValueFilter.Factory	A factory for creating an annotation value filter for an annotation's target.
Argument	Parameters that are annotated with this annotation will be assigned the value of the parameter of the source method with the given parameter.
Argument.Binder	A binder for handling the Argument annotation.
Argument.BindingMechanic	Determines if a parameter binding should be considered for resolving ambiguous method bindings.
ArgumentTypeResolver	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.
ArgumentTypeResolver.ParameterIndexToken	This token is used to mark a one-to-one binding of a source method parameter to a target method parameter.
ArgumentTypeResolver.PrimitiveTypePrecedence	A representation of the precedence of a most specific primitive type in the Java programming language.
ArrayAccess	Allows accessing array values.
ArrayFactory	A CollectionFactory that is capable of creating an array of a given type with any number of given values.
ArrayFactory.ArrayCreator	An array creator is responsible for providing correct byte code instructions for creating an array and for storing values into it.
ArrayFactory.ArrayCreator.ForPrimitiveType	An array creator implementation for primitive types.
ArrayFactory.ArrayCreator.ForReferenceType	An array creator implementation for reference types.
ArrayTypeMatcher<T extends TypeDefinition>	Matches an enumeration type.
AsmVisitorWrapper	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.
AsmVisitorWrapper.AbstractBase	An abstract base implementation of an ASM visitor wrapper that does not set any flags.
AsmVisitorWrapper.Compound	An ordered, immutable chain of AsmVisitorWrappers.
AsmVisitorWrapper.ForDeclaredFields	An ASM visitor wrapper that allows to wrap declared fields of the instrumented type with a AsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper.
AsmVisitorWrapper.ForDeclaredFields.Entry	An entry describing a field visitor wrapper paired with a matcher for fields to be wrapped.
AsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper	A field visitor wrapper that allows for wrapping a FieldVisitor defining a declared field.
AsmVisitorWrapper.ForDeclaredMethods	An ASM visitor wrapper that allows to wrap declared methods of the instrumented type with a AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper.
AsmVisitorWrapper.ForDeclaredMethods.Entry	An entry describing a method visitor wrapper paired with a matcher for fields to be wrapped.
AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper	A method visitor wrapper that allows for wrapping a MethodVisitor defining a declared method.
AsmVisitorWrapper.NoOp	A class visitor wrapper that does not apply any changes.
Assigner	An assigner is responsible for converting some type A to another type B if possible.
Assigner.EqualTypesOnly	An assigner that only allows to assign types if they are equal to another.
Assigner.Refusing	An assigner that does not allow any assignments.
Assigner.Typing	Indicates for a type assignment, if a type casting should be applied in case that two types are not statically assignable.
Attacher	A Java program that attaches a Java agent to an external process.
AuxiliaryType	An auxiliary type that provides services to the instrumentation of another type.
AuxiliaryType.NamingStrategy	Representation of a naming strategy for an auxiliary type.
AuxiliaryType.NamingStrategy.SuffixingRandom	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.
AuxiliaryType.SignatureRelevant	A marker to indicate that an auxiliary type is part of the instrumented types signature.
BindingPriority	Defines a binding priority for a target method.
BindingPriority.Resolver	An ambiguity resolver that considers the priority of a method as defined by the BindingPriority annotation.
BooleanMatcher<T>	An element matcher that returns a fixed result.
BuildLogger	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.
BuildLogger.Adapter	An abstract adapter implementation for a build logger.
BuildLogger.Compound	A compound build logger.
BuildLogger.NoOp	A non-operational build logger that discards all statements.
BuildLogger.StreamWriting	A build logger that writes all statements to a PrintStream.
ByteArrayClassLoader	A ClassLoader that is capable of loading explicitly defined classes.
ByteArrayClassLoader.ChildFirst	A ByteArrayClassLoader which applies child-first semantics for the given type definitions.
ByteArrayClassLoader.ChildFirst.PrependingEnumeration	An enumeration that prepends an element to another enumeration and skips the last element of the provided enumeration.
ByteArrayClassLoader.EmptyEnumeration	An enumeration without any elements.
ByteArrayClassLoader.PackageLookupStrategy	A package lookup strategy for locating a package by name.
ByteArrayClassLoader.PackageLookupStrategy.CreationAction	A creation action for a package lookup strategy.
ByteArrayClassLoader.PackageLookupStrategy.ForJava9CapableVm	A package lookup strategy for Java 9 or newer.
ByteArrayClassLoader.PackageLookupStrategy.ForLegacyVm	A package lookup strategy for a VM prior to Java 9.
ByteArrayClassLoader.PersistenceHandler	A persistence handler decides on whether the byte array that represents a loaded class is exposed by the ClassLoader.getResourceAsStream(String) method.
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction	An action to define a URL that represents a class file.
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction.ByteArrayUrlStreamHandler	A stream handler that returns the given binary representation.
ByteArrayClassLoader.PersistenceHandler.UrlDefinitionAction.ByteArrayUrlStreamHandler.ByteArrayUrlConnection	A URL connection for a given byte array.
ByteArrayClassLoader.SingletonEnumeration	An enumeration that contains a single element.
ByteArrayClassLoader.SynchronizationStrategy	An engine for receiving a class loading lock when loading a class.
ByteArrayClassLoader.SynchronizationStrategy.CreationAction	A creation action for a synchronization strategy.
ByteArrayClassLoader.SynchronizationStrategy.ForJava7CapableVm	A synchronization engine for a VM that is aware of parallel-capable class loaders.
ByteArrayClassLoader.SynchronizationStrategy.ForJava8CapableVm	A synchronization engine for a VM that is aware of parallel-capable class loaders using method handles to respect module boundaries.
ByteArrayClassLoader.SynchronizationStrategy.ForLegacyVm	A synchronization engine for a VM that is not aware of parallel-capable class loaders.
ByteArrayClassLoader.SynchronizationStrategy.Initializable	An uninitialized synchronization strategy.
ByteBuddy	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.
ByteBuddy.EnumerationImplementation	An implementation fo the values method of an enumeration type.
ByteBuddy.EnumerationImplementation.InitializationAppender	A byte code appender for the type initializer of any enumeration type.
ByteBuddy.EnumerationImplementation.ValuesMethodAppender	A byte code appender for the values method of any enumeration type.
ByteBuddy.RecordConstructorStrategy	A constructor strategy for implementing a Java record.
ByteBuddy.RecordConstructorStrategy.Appender	A byte code appender for accessors and the record constructor.
ByteBuddy.RecordObjectMethod	Implements the object methods of the Java record type.
ByteBuddyAgent	The Byte Buddy agent provides a JVM Instrumentation in order to allow Byte Buddy the redefinition of already loaded classes.
ByteBuddyAgent.AgentProvider	An agent provider is responsible for handling and providing the jar file of an agent that is being attached.
ByteBuddyAgent.AgentProvider.ForByteBuddyAgent	An agent provider for a temporary Byte Buddy agent.
ByteBuddyAgent.AgentProvider.ForExistingAgent	An agent provider that supplies an existing agent that is not deleted after attachment.
ByteBuddyAgent.AttachmentProvider	An attachment provider is responsible for making the Java attachment API available.
ByteBuddyAgent.AttachmentProvider.Accessor	An accessor for a JVM's attachment API.
ByteBuddyAgent.AttachmentProvider.Accessor.ExternalAttachment	Describes an external attachment to a Java virtual machine.
ByteBuddyAgent.AttachmentProvider.Accessor.Simple	A simple implementation of an accessible accessor.
ByteBuddyAgent.AttachmentProvider.Accessor.Simple.WithDirectAttachment	A simple implementation of an accessible accessor that attaches using a virtual machine emulation that does not require external attachment.
ByteBuddyAgent.AttachmentProvider.Accessor.Simple.WithExternalAttachment	A simple implementation of an accessible accessor that allows for external attachment.
ByteBuddyAgent.AttachmentProvider.Accessor.Unavailable	A canonical implementation of an unavailable accessor.
ByteBuddyAgent.AttachmentProvider.Compound	A compound attachment provider that attempts the attachment by delegation to other providers.
ByteBuddyAgent.AttachmentProvider.ForEmulatedAttachment	An attachment provider that uses Byte Buddy's attachment API emulation.
ByteBuddyAgent.AttachmentProvider.ForJ9Vm	An attachment provider that locates the attach API directly from the system class loader expecting an IBM J9 VM.
ByteBuddyAgent.AttachmentProvider.ForModularizedVm	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.
ByteBuddyAgent.AttachmentProvider.ForStandardToolsJarVm	An attachment provider that is dependant on the existence of a tools.jar file on the local file system.
ByteBuddyAgent.AttachmentProvider.ForUserDefinedToolsJar	An attachment provider that attempts to locate a tools.jar from a custom location set via a system property.
ByteBuddyAgent.AttachmentTypeEvaluator	An attachment evaluator is responsible for deciding if an agent can be attached from the current process.
ByteBuddyAgent.AttachmentTypeEvaluator.Disabled	An attachment type evaluator that never requires external attachment.
ByteBuddyAgent.AttachmentTypeEvaluator.ForJava9CapableVm	An attachment type evaluator that checks a process id against the current process id.
ByteBuddyAgent.AttachmentTypeEvaluator.InstallationAction	An installation action for creating an attachment type evaluator.
ByteBuddyAgent.ProcessProvider	A process provider is responsible for providing the process id of the current VM.
ByteBuddyAgent.ProcessProvider.ForCurrentVm	Supplies the current VM's process id.
ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForJava9CapableVm	A process provider for a Java 9 capable VM with access to the introduced process API.
ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForLegacyVm	A process provider for a legacy VM that reads the process id from its JMX properties.
ByteBuddyMojo	A Maven plugin for applying Byte Buddy transformations during a build.
ByteBuddyMojo.FilePrefixMatcher	Matches elements which represent a Java class that is represented in the list or an inner class of the classes represented in the list.
ByteBuddyMojo.ForProductionTypes	A Byte Buddy plugin that transforms a project's production class files.
ByteBuddyMojo.ForTestTypes	A Byte Buddy plugin that transforms a project's test class files.
ByteBuddyMojo.MavenBuildLogger	A BuildLogger implementation for a Maven Log.
ByteBuddyMojo.TransformationLogger	A Plugin.Engine.Listener that logs several relevant events during the build.
ByteBuddyMojo.Transformer	A transformer that is applied during the plugin's execution.
ByteBuddyMojo.Transformer.ForConfiguredPlugin	A transformer for an explicitly configured plugin.
ByteBuddyMojo.Transformer.ForDiscoveredPlugin	A transformer for a discovered plugin.
ByteCodeAppender	An appender that generates the byte code for a given method.
ByteCodeAppender.Compound	A compound appender that combines a given number of other byte code appenders.
ByteCodeAppender.Simple	A simple byte code appender that only represents a given array of StackManipulations.
ByteCodeAppender.Size	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.
ByteCodeElement	Implementations describe an element represented in byte code, i.e.
ByteCodeElement.Token<T extends ByteCodeElement.Token<T>>	A token representing a byte code element.
ByteCodeElement.Token.TokenList<S extends ByteCodeElement.Token<S>>	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.
CachedReturnPlugin	A plugin that caches the return value of a method in a synthetic field.
CachedReturnPlugin.CacheField	Indicates the field that stores the cached value.
CachedReturnPlugin.CacheFieldOffsetMapping	An offset mapping for the cached field.
CachedReturnPlugin.Enhance	Indicates methods that should be cached, i.e.
CachedReturnPlugin$boolean	An advice class for caching a boolean value.
CachedReturnPlugin$byte	An advice class for caching a byte value.
CachedReturnPlugin$char	An advice class for caching a char value.
CachedReturnPlugin$double	An advice class for caching a double value.
CachedReturnPlugin$float	An advice class for caching a float value.
CachedReturnPlugin$int	An advice class for caching a int value.
CachedReturnPlugin$long	An advice class for caching a long value.
CachedReturnPlugin$Object	An advice class for caching a reference value.
CachedReturnPlugin$short	An advice class for caching a short value.
CachingMatcher<T>	A matcher that remembers the results of previously matching an equal target.
CachingMatcher.WithInlineEviction<S>	A caching matcher with inline cache eviction.
ClassConstant	Represents a constant representing any loaded Java Class.
ClassConstant.ForReferenceType	A class constant for a non-primitive Class.
ClassFileLocator	Locates a class file or its byte array representation when it is given its type description.
ClassFileLocator.AgentBased	A Java agent that allows the location of class files by emulating a retransformation.
ClassFileLocator.AgentBased.ClassLoadingDelegate	A delegate that is queried for loading a class.
ClassFileLocator.AgentBased.ClassLoadingDelegate.Default	A default implementation of a class loading delegate.
ClassFileLocator.AgentBased.ClassLoadingDelegate.Explicit	A class loading delegate that allows the location of explicitly registered classes that cannot be located by a class loader directly.
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader	A class loading delegate that accounts for a sun.reflect.DelegatingClassLoader which cannot load its own classes by name.
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher	Representation of a Java Field.
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.CreationAction	An action for creating a dispatcher.
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Initializable	An uninitialized version of a dispatcher for extracting a class loader's loaded classes.
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Resolved	Represents a field that could be located.
ClassFileLocator.AgentBased.ClassLoadingDelegate.ForDelegatingClassLoader.Dispatcher.Unresolved	Represents a field that could not be located.
ClassFileLocator.AgentBased.Dispatcher	A dispatcher to interact with the Instrumentation API.
ClassFileLocator.AgentBased.Dispatcher.CreationAction	An action to create a ClassFileLocator.AgentBased.Dispatcher.
ClassFileLocator.AgentBased.Dispatcher.ForJava6CapableVm	A dispatcher for a Java 6 capable VM.
ClassFileLocator.AgentBased.Dispatcher.ForLegacyVm	A dispatcher for a VM that does not support retransformation.
ClassFileLocator.AgentBased.ExtractionClassFileTransformer	A non-operational class file transformer that remembers the binary format of a given class.
ClassFileLocator.Compound	A compound ClassFileLocator that chains several locators.
ClassFileLocator.ForClassLoader	A class file locator that queries a class loader for binary representations of class files.
ClassFileLocator.ForClassLoader.BootLoaderProxyCreationAction	A privileged action for creating a proxy class loader for the boot class loader.
ClassFileLocator.ForClassLoader.WeaklyReferenced	A class file locator that queries a class loader for binary representations of class files.
ClassFileLocator.ForFolder	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.
ClassFileLocator.ForJarFile	A class file locator that locates classes within a Java jar file.
ClassFileLocator.ForModule	A class file locator that locates class files by querying a Java module's getResourceAsStream method.
ClassFileLocator.ForModule.WeaklyReferenced	A class file locator for a Java module that only references this module weakly.
ClassFileLocator.ForModuleFile	A class file locator that locates classes within a Java jmod file.
ClassFileLocator.ForUrl	A class file locator that reads class files from one or several URLs.
ClassFileLocator.ForUrl.ClassLoaderCreationAction	An action to create a class loader with the purpose of locating classes from an URL location.
ClassFileLocator.NoOp	A class file locator that cannot locate any class files.
ClassFileLocator.PackageDiscriminating	A class file locator that discriminates by a type's package.
ClassFileLocator.Resolution	Represents a class file as binary data.
ClassFileLocator.Resolution.Explicit	Represents a byte array as binary data.
ClassFileLocator.Resolution.Illegal	A canonical representation of an illegal binary representation.
ClassFileLocator.Simple	A simple class file locator that returns class files from a selection of given types.
ClassFileVersion	A wrapper object for representing a validated class file version in the format that is specified by the JVMS.
ClassFileVersion.VersionLocator	A locator for the executing VM's Java version.
ClassFileVersion.VersionLocator.CreationAction	A creation action for a version locator.
ClassFileVersion.VersionLocator.ForJava9CapableVm	A version locator for a JVM of at least version 9.
ClassFileVersion.VersionLocator.ForLegacyVm	A version locator for a JVM that does not provide the java.lang.Runtime.Version class.
ClassInjector	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.
ClassInjector.AbstractBase	An abstract base implementation of a class injector.
ClassInjector.UsingInstrumentation	A class injector using a Instrumentation to append to either the boot classpath or the system class path.
ClassInjector.UsingInstrumentation.Dispatcher	A dispatcher to interact with the instrumentation API.
ClassInjector.UsingInstrumentation.Dispatcher.CreationAction	An action to create a dispatcher for interacting with the instrumentation API.
ClassInjector.UsingInstrumentation.Dispatcher.ForJava6CapableVm	A dispatcher for a VM that is capable of appending to the boot and system class loader.
ClassInjector.UsingInstrumentation.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM that is not capable of appending jar files using instrumentation.
ClassInjector.UsingInstrumentation.Target	A representation of the target to which Java classes should be appended to.
ClassInjector.UsingLookup	A class injector that uses a java.lang.invoke.MethodHandles$Lookup object for defining a class.
ClassInjector.UsingLookup.Dispatcher	A dispatcher for interacting with a method handle lookup.
ClassInjector.UsingLookup.Dispatcher.Creator	An action for defining a dispatcher.
ClassInjector.UsingLookup.Dispatcher.ForJava9CapableVm	A dispatcher for a Java 9 capable VM that supports class definition via method handles.
ClassInjector.UsingLookup.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM that does not support class definition via method handles.
ClassInjector.UsingReflection	A class injector that uses reflective method calls.
ClassInjector.UsingReflection.Dispatcher	A dispatcher for accessing a ClassLoader reflectively.
ClassInjector.UsingReflection.Dispatcher.CreationAction	A creation action for a dispatcher.
ClassInjector.UsingReflection.Dispatcher.Direct	A class injection dispatcher that is using reflection on the ClassLoader methods.
ClassInjector.UsingReflection.Dispatcher.Direct.ForJava7CapableVm	A resolved class dispatcher for a class injector on a VM running at least Java 7.
ClassInjector.UsingReflection.Dispatcher.Direct.ForLegacyVm	A resolved class dispatcher for a class injector prior to Java 7.
ClassInjector.UsingReflection.Dispatcher.Initializable	Initializes a dispatcher to make non-accessible APIs accessible.
ClassInjector.UsingReflection.Dispatcher.Initializable.Unavailable	Represents an unsuccessfully loaded method lookup.
ClassInjector.UsingReflection.Dispatcher.Unavailable	Represents an unsuccessfully loaded method lookup.
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeInjection	An indirect dispatcher that uses a redirection accessor class that was injected into the bootstrap class loader.
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeOverride	A dispatcher implementation that uses sun.misc.Unsafe#putBoolean to set the AccessibleObject field for making methods accessible.
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeOverride.ForJava7CapableVm	A resolved class dispatcher using unsafe field injection for a class injector on a VM running at least Java 7.
ClassInjector.UsingReflection.Dispatcher.UsingUnsafeOverride.ForLegacyVm	A resolved class dispatcher using unsafe field injection for a class injector prior to Java 7.
ClassInjector.UsingUnsafe	A class injector that uses sun.misc.Unsafe to inject classes.
ClassInjector.UsingUnsafe.Dispatcher	A dispatcher for using sun.misc.Unsafe.
ClassInjector.UsingUnsafe.Dispatcher.CreationAction	A privileged action for creating a dispatcher.
ClassInjector.UsingUnsafe.Dispatcher.Enabled	An enabled dispatcher.
ClassInjector.UsingUnsafe.Dispatcher.Initializable	A class injection dispatcher that is not yet initialized.
ClassInjector.UsingUnsafe.Dispatcher.Unavailable	A disabled dispatcher.
ClassInjector.UsingUnsafe.Factory	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.
ClassInjector.UsingUnsafe.Factory.AccessResolver	An access resolver that invokes AccessibleObject.setAccessible(boolean) to true in a given privilege scope.
ClassInjector.UsingUnsafe.Factory.AccessResolver.Default	A default access resolver that uses Byte Buddy's privilege scope.
ClassLoaderHierarchyMatcher<T extends java.lang.ClassLoader>	An element matcher that matches all ClassLoaders in the matched class loaders hierarchy against a given matcher.
ClassLoaderParentMatcher<T extends java.lang.ClassLoader>	An element matcher that matches a class loader for being a parent of the given class loader.
ClassLoaderResolver	A resolver that transforms a Maven coordinate into a class loader that can view the dependencies implied by this coordinate.
ClassLoadingStrategy<T extends java.lang.ClassLoader>	A strategy for loading a collection of types.
ClassLoadingStrategy.Configurable<S extends java.lang.ClassLoader>	A ClassLoadingStrategy that allows configuring the strategy's behavior.
ClassLoadingStrategy.Default	This class contains implementations of default class loading strategies.
ClassLoadingStrategy.Default.InjectionDispatcher	A class loading strategy which applies a class loader injection while applying a given ProtectionDomain on class injection.
ClassLoadingStrategy.Default.WrappingDispatcher	A class loading strategy which creates a wrapping class loader while applying a given ProtectionDomain on class loading.
ClassLoadingStrategy.ForBootstrapInjection	A class loading strategy which allows class injection into the bootstrap class loader if appropriate.
ClassLoadingStrategy.ForUnsafeInjection	A class loading strategy that injects a class using sun.misc.Unsafe.
ClassLoadingStrategy.UsingLookup	A class loading strategy that uses a java.lang.invoke.MethodHandles$Lookup instance for defining types.
ClassReloadingStrategy	The class reloading strategy allows to redefine loaded Classes.
ClassReloadingStrategy.BootstrapInjection	A strategy to apply for injecting classes into the bootstrap class loader.
ClassReloadingStrategy.BootstrapInjection.Disabled	A disabled bootstrap injection strategy.
ClassReloadingStrategy.BootstrapInjection.Enabled	An enabled bootstrap class loader injection strategy.
ClassReloadingStrategy.Dispatcher	A dispatcher to interact with the instrumentation API.
ClassReloadingStrategy.Dispatcher.CreationAction	An action to create an appropriate ClassReloadingStrategy.Dispatcher.
ClassReloadingStrategy.Dispatcher.ForJava6CapableVm	A dispatcher for a Java 6 capable VM that is potentially capable of retransformation.
ClassReloadingStrategy.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM that does not support retransformation.
ClassReloadingStrategy.Strategy	A strategy which performs the actual redefinition of a Class.
ClassReloadingStrategy.Strategy.ClassRedefinitionTransformer	A class file transformer that applies a given ClassDefinition.
ClassReloadingStrategy.Strategy.ClassResettingTransformer	A transformer that indicates that a class file should not be transformed.
ClassWriterStrategy	A class writer strategy is responsible for the creation of a ClassWriter when creating a type.
ClassWriterStrategy.Default	Default implementations of class writer strategies.
ClassWriterStrategy.FrameComputingClassWriter	A class writer that piggy-backs on Byte Buddy's TypePool to avoid class loading or look-up errors when redefining a class.
CollectionElementMatcher<T>	A matcher that matches a given element of a collection.
CollectionErasureMatcher<T extends java.lang.Iterable<? extends TypeDefinition>>	An element matcher that matches a collection of types by their erasures.
CollectionFactory	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.
CollectionItemMatcher<T>	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.
CollectionOneToOneMatcher<T>	An element matcher that matches a given iterable collection to a list of matchers on a per-element basis.
CollectionSizeMatcher<T extends java.lang.Iterable<?>>	An element matcher that matches a collection by its size.
CompoundList	Creates a list representation of two lists as a single, compound list.
ConstructorStrategy	A constructor strategy is responsible for creating bootstrap constructors for a SubclassDynamicTypeBuilder.
ConstructorStrategy.Default	Default implementations of constructor strategies.
ConstructorStrategy.Default.WithMethodAttributeAppenderFactory	A wrapper for a default constructor strategy which additionally applies a method attribute appender factory.
ConstructorStrategy.ForDefaultConstructor	A constructor strategy that creates a default constructor that invokes a super constructor with default arguments.
CoordinateConfiguration	An configuration of a Maven coordinate.
DeclaredByType	This interface represents all elements that can be declared within a type, i.e.
DeclaringAnnotationMatcher<T extends AnnotationSource>	An element matcher that matches the list of annotations that are provided by an annotated element.
DeclaringFieldMatcher<T extends TypeDefinition>	An element matcher that checks if a type description declares fields of a given property.
DeclaringMethodMatcher<T extends TypeDefinition>	An element matcher that checks if a type description declares methods of a given property.
DeclaringTypeMatcher<T extends DeclaredByType>	An element matcher that matches the declaring type of another element, only if this element is actually declared in a type.
DeclaringTypeResolver	This ambiguity resolver matches that method out of two methods that is declared by the more specific type.
DecoratingDynamicTypeBuilder<T>	A type builder that decorates a type by allowing for the application of attribute changes and ASM visitor wrappers.
Default	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.
Default.Binder	A binder for the Default annotation.
Default.Binder.TypeLocator	Locates the type which should be the base type of the created proxy.
Default.Binder.TypeLocator.ForParameterType	A type locator that yields the target parameter's type.
Default.Binder.TypeLocator.ForType	A type locator that returns a given type.
DefaultCall	A parameter with this annotation is assigned a proxy for invoking a default method that fits the intercepted method.
DefaultCall.Binder	A binder for handling the DefaultCall annotation.
DefaultCall.Binder.DefaultMethodLocator	A default method locator is responsible for looking up a default method to a given source method.
DefaultCall.Binder.DefaultMethodLocator.Explicit	An explicit default method locator attempts to look up a default method in the specified interface type.
DefaultCall.Binder.DefaultMethodLocator.Implicit	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.
DefaultMethod	A parameter with this annotation is assigned an instance of Method which invokes a default method implementation of this method.
DefaultMethod.Binder	A binder for the DefaultMethod annotation.
DefaultMethod.Binder.DelegationMethod	Loads the delegation method constant onto the stack.
DefaultMethod.Binder.MethodLocator	A method locator is responsible for creating the super method call.
DefaultMethod.Binder.MethodLocator.ForExplicitType	A method locator for an explicit target type.
DefaultMethod.Binder.MethodLocator.ForImplicitType	A method locator for an implicit target type.
DefaultMethodCall	This Implementation invokes a default method for the methods it instruments.
DefaultMethodCall.Appender	The appender for implementing a DefaultMethodCall.
DefaultValue	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.
DescriptorMatcher<T extends NamedElement.WithDescriptor>	An element matcher that matches a Java descriptor.
DoubleConstant	This class is responsible for loading any double constant onto the operand stack.
DoubleConstant.ConstantPool	A stack manipulation for loading a double value from a class's constant pool onto the operand stack.
Duplication	Duplicates a value that is lying on top of the stack.
Duplication.WithFlip	A duplication that flips a value over the second value on the operand stack.
DynamicType	A dynamic type that is created at runtime, usually as the result of applying a DynamicType.Builder or as the result of an AuxiliaryType.
DynamicType.Builder<T>	A builder for creating a dynamic type.
DynamicType.Builder.AbstractBase<S>	An abstract base implementation of a dynamic type builder.
DynamicType.Builder.AbstractBase.Adapter<U>	An adapter implementation of a dynamic type builder.
DynamicType.Builder.AbstractBase.Delegator<U>	A delegator for a dynamic type builder delegating all invocations to another dynamic type builder.
DynamicType.Builder.FieldDefinition<S>	A builder for a field definition.
DynamicType.Builder.FieldDefinition.Optional<U>	A builder for an optional field definition.
DynamicType.Builder.FieldDefinition.Optional.AbstractBase<U>	An abstract base implementation for an optional field definition.
DynamicType.Builder.FieldDefinition.Optional.Valuable<V>	A builder for an optional field definition that allows for defining a value.
DynamicType.Builder.FieldDefinition.Optional.Valuable.AbstractBase<U>	An abstract base implementation of an optional field definition that allows for defining a value.
DynamicType.Builder.FieldDefinition.Optional.Valuable.AbstractBase.Adapter<V>	An adapter for an optional field definition that allows for defining a value.
DynamicType.Builder.FieldDefinition.Valuable<U>	A builder for a field definition that allows for defining a value.
DynamicType.Builder.InnerTypeDefinition<S>	An inner type definition for defining a type that is contained within another type, method or constructor.
DynamicType.Builder.InnerTypeDefinition.ForType<U>	An inner type definition for defining a type that is contained within another type.
DynamicType.Builder.MethodDefinition<S>	A builder for a method definition.
DynamicType.Builder.MethodDefinition.AbstractBase<U>	An abstract base implementation of a method definition.
DynamicType.Builder.MethodDefinition.AbstractBase.Adapter<V>	An adapter implementation of a method definition.
DynamicType.Builder.MethodDefinition.ExceptionDefinition<U>	A builder for defining an implementation of a method and optionally defining a type variable or thrown exception.
DynamicType.Builder.MethodDefinition.ExceptionDefinition.AbstractBase<V>	An abstract base implementation for defining an implementation of a method and optionally defining a type variable or thrown exception.
DynamicType.Builder.MethodDefinition.ImplementationDefinition<U>	A builder for defining an implementation of a method.
DynamicType.Builder.MethodDefinition.ImplementationDefinition.AbstractBase<V>	An abstract base implementation for a builder optionally defining an implementation of a method.
DynamicType.Builder.MethodDefinition.ImplementationDefinition.Optional<V>	A builder for optionally defining an implementation of a method.
DynamicType.Builder.MethodDefinition.ParameterDefinition<U>	A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or method parameter.
DynamicType.Builder.MethodDefinition.ParameterDefinition.AbstractBase<V>	An abstract base implementation for defining an implementation of a method and optionally defining a type variable, thrown exception or parameter type.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Annotatable<V>	A builder for optionally defining an annotation on a parameter.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Annotatable.AbstractBase<W>	An abstract base implementation for defining an annotation on a parameter.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Annotatable.AbstractBase.Adapter<X>	An adapter implementation for defining an annotation on a parameter.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial<V>	A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or method parameter.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Initial.AbstractBase<W>	An abstract base implementation for an initial parameter definition.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple<V>	A builder for defining an implementation of a method and optionally defining a type variable, thrown exception or a parameter type.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.AbstractBase<W>	An abstract base implementation of an exception definition.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.Annotatable<V>	A builder for optionally defining an annotation on a parameter.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.Annotatable.AbstractBase<W>	An abstract base implementation of a simple parameter definition.
DynamicType.Builder.MethodDefinition.ParameterDefinition.Simple.Annotatable.AbstractBase.Adapter<X>	An adapter implementation of a simple parameter definition.
DynamicType.Builder.MethodDefinition.ReceiverTypeDefinition<U>	A builder for a method definition with a receiver type.
DynamicType.Builder.MethodDefinition.ReceiverTypeDefinition.AbstractBase<V>	An abstract base implementation of a method definition that can accept a receiver type.
DynamicType.Builder.MethodDefinition.TypeVariableDefinition<U>	A builder for defining an implementation of a method and optionally defining a type variable.
DynamicType.Builder.MethodDefinition.TypeVariableDefinition.AbstractBase<V>	An abstract base implementation for defining an implementation of a method and optionally defining a type variable.
DynamicType.Builder.MethodDefinition.TypeVariableDefinition.Annotatable<V>	A builder for optionally defining an annotation for a type variable.
DynamicType.Builder.MethodDefinition.TypeVariableDefinition.Annotatable.AbstractBase<W>	An abstract base implementation for defining an annotation on a parameter.
DynamicType.Builder.MethodDefinition.TypeVariableDefinition.Annotatable.AbstractBase.Adapter<X>	An adapter implementation for an annotatable type variable definition.
DynamicType.Builder.RecordComponentDefinition<S>	A builder for a record component definition.
DynamicType.Builder.RecordComponentDefinition.Optional<U>	A DynamicType.Builder.RecordComponentDefinition as an optional build step.
DynamicType.Builder.RecordComponentDefinition.Optional.AbstractBase<U>	An abstract base implementation of a record definition.
DynamicType.Builder.TypeVariableDefinition<S>	A builder for a type variable definition.
DynamicType.Builder.TypeVariableDefinition.AbstractBase<U>	An abstract base implementation of a type variable definition.
DynamicType.Default	A default implementation of a dynamic type.
DynamicType.Default.Dispatcher	A dispatcher that allows for file copy operations based on NIO2 if available.
DynamicType.Default.Dispatcher.CreationAction	An action for creating a dispatcher.
DynamicType.Default.Dispatcher.ForJava7CapableVm	A dispatcher for VMs that are capable of NIO2.
DynamicType.Default.Dispatcher.ForLegacyVm	A legacy dispatcher that is not capable of NIO.
DynamicType.Default.Loaded<T>	A default implementation of a loaded dynamic type.
DynamicType.Default.Unloaded<T>	A default implementation of an unloaded dynamic type.
DynamicType.Loaded<T>	A dynamic type that has been loaded into the running instance of the Java virtual machine.
DynamicType.Unloaded<T>	A dynamic type that has not yet been loaded by a given ClassLoader.
ElementMatcher<T>	An element matcher is used as a predicate for identifying code elements such as types, methods, fields or annotations.
ElementMatcher.Junction<S>	A junctions allows to chain different ElementMatchers in a readable manner.
ElementMatcher.Junction.AbstractBase<V>	A base implementation of ElementMatcher.Junction.
ElementMatcher.Junction.Conjunction<W>	A conjunction matcher which only matches an element if both represented matchers constitute a match.
ElementMatcher.Junction.Disjunction<W>	A disjunction matcher which only matches an element if both represented matchers constitute a match.
ElementMatchers	A utility class that contains a human-readable language for creating ElementMatchers.
Empty	Binds the parameter type's default value to the annotated parameter, i.e.
Empty.Binder	A binder for the Empty annotation.
EntryPoint	An entry point for a build tool which is responsible for the transformation's configuration.
EntryPoint.Default	Default implementations for an entry point.
EnumerationDescription	Describes an enumeration value.
EnumerationDescription.AbstractBase	An adapter implementation of an enumeration description.
EnumerationDescription.ForLoadedEnumeration	An enumeration description representing a loaded enumeration.
EnumerationDescription.Latent	A latent description of an enumeration value.
EnumerationState	Determines if a type describes an enumeration.
EqualityMatcher<T>	An element matcher that checks an object's equality to another object.
EqualsMethod	An implementation of Object.equals(Object) that takes a class's declared fields into consideration.
EqualsMethod.Appender	A byte code appender to implement the EqualsMethod.
EqualsMethod.CompoundComparator	A compound comparator that compares the values of multiple fields.
EqualsMethod.ConditionalReturn	A conditional return aborts the equality computation if a given condition was reached.
EqualsMethod.NaturalOrderComparator	A comparator that retains the natural order.
EqualsMethod.NullValueGuard	Guards a field value against a potential null value.
EqualsMethod.NullValueGuard.NoOp	A non-operational null value guard.
EqualsMethod.NullValueGuard.UsingJump	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.
EqualsMethod.SuperClassCheck	Checks the equality contract against the super class.
EqualsMethod.TypeCompatibilityCheck	Checks the overall type of the provided argument.
EqualsMethod.TypePropertyComparator	A comparator that sorts fields by a type property.
EqualsMethod.ValueComparator	A value comparator is responsible to compare to values of a given type.
ErasureMatcher<T extends TypeDefinition>	An element matcher that matches its argument's TypeDescription.Generic raw type against the given matcher for a TypeDescription.
ExceptionMethod	This implementation causes a Throwable to be thrown when the instrumented method is invoked.
ExceptionMethod.ConstructionDelegate	A construction delegate is responsible for calling a Throwable's constructor.
ExceptionMethod.ConstructionDelegate.ForDefaultConstructor	A construction delegate that calls the default constructor.
ExceptionMethod.ConstructionDelegate.ForStringConstructor	A construction delegate that calls a constructor that takes a single string as its argument.
ExceptionTableSensitiveMethodVisitor	A MethodVisitor that adds a callback after visiting the exception table of a method.
FailSafeMatcher<T>	A fail-safe matcher catches exceptions that are thrown by a delegate matcher and returns an alternative value.
FieldAccess	An access representation to a given field.
FieldAccess.Defined	Representation of a field access for which a getter and a setter can be created.
FieldAccess.OfGenericField	A dispatcher for implementing a generic read or write access on a field.
FieldAccessor	Defines a method to access a given field by following the Java bean conventions for getters and setters:
FieldAccessor.AssignerConfigurable	A field accessor that can be configured to use a given assigner and runtime type use configuration.
FieldAccessor.FieldLocation	A field location represents an identified field description which depends on the instrumented type and method.
FieldAccessor.FieldLocation.Absolute	An absolute field description representing a previously resolved field.
FieldAccessor.FieldLocation.Prepared	A prepared field location.
FieldAccessor.FieldLocation.Relative	A relative field location where a field is located dynamically.
FieldAccessor.FieldLocation.Relative.Prepared	A prepared version of a field location.
FieldAccessor.FieldNameExtractor	A field name extractor is responsible for determining a field name to a method that is implemented to access this method.
FieldAccessor.FieldNameExtractor.ForBeanProperty	A FieldAccessor.FieldNameExtractor that determines a field name according to the rules of Java bean naming conventions.
FieldAccessor.FieldNameExtractor.ForFixedValue	A field name extractor that returns a fixed value.
FieldAccessor.ForImplicitProperty	A field accessor for an implicit property where a getter or setter property is inferred from the signature.
FieldAccessor.ForSetter<T>	A field accessor for a field setter.
FieldAccessor.ForSetter.OfConstantValue	An instrumentation that sets a constant value to a field.
FieldAccessor.ForSetter.OfDefaultValue	A setter instrumentation that sets a null or a primitive type's default value.
FieldAccessor.ForSetter.OfFieldValue	A setter that reads a value of another field and sets this value.
FieldAccessor.ForSetter.OfParameterValue	A setter instrumentation for a parameter value.
FieldAccessor.ForSetter.OfReferenceValue	An instrumentation that sets a field to a reference value that is stored in a static field of the instrumented type.
FieldAccessor.ForSetter.TerminationHandler	A termination handler is responsible for handling a field accessor's return.
FieldAccessor.OwnerTypeLocatable	A field accessor that can be configured to locate a field in a specific manner.
FieldAccessor.PropertyConfigurable	A field accessor that allows to define the access to be a field write of a given argument.
FieldAttributeAppender	An appender that writes attributes or annotations to a given ASM FieldVisitor.
FieldAttributeAppender.Compound	A field attribute appender that combines several method attribute appenders to be represented as a single field attribute appender.
FieldAttributeAppender.Explicit	Appends an annotation to a field.
FieldAttributeAppender.Factory	A factory that creates field attribute appenders for a given type.
FieldAttributeAppender.Factory.Compound	A field attribute appender factory that combines several field attribute appender factories to be represented as a single factory.
FieldAttributeAppender.ForInstrumentedField	An attribute appender that writes all annotations that are declared on a field.
FieldAttributeAppender.NoOp	A field attribute appender that does not append any attributes.
FieldConstant	Represents a Field constant for a given type.
FieldConstant.Cached	A cached version of a FieldConstant.
FieldDescription	Implementations of this interface describe a Java field.
FieldDescription.AbstractBase	An abstract base implementation of a field description.
FieldDescription.ForLoadedField	An implementation of a field description for a loaded field.
FieldDescription.InDefinedShape	Represents a field in its defined shape, i.e.
FieldDescription.InDefinedShape.AbstractBase	An abstract base implementation of a field description in its defined shape.
FieldDescription.InGenericShape	Represents a field description in its generic shape, i.e.
FieldDescription.Latent	A latent field description describes a field that is not attached to a declaring TypeDescription.
FieldDescription.SignatureToken	A token that uniquely identifies a field by its name and type erasure.
FieldDescription.Token	A token representing a field's properties detached from a type.
FieldDescription.TypeSubstituting	A field description that represents a given field but with a substituted field type.
FieldList<T extends FieldDescription>	Implementations represent a list of field descriptions.
FieldList.AbstractBase<S extends FieldDescription>	An abstract base implementation of a FieldList.
FieldList.Empty<S extends FieldDescription>	An implementation of an empty field list.
FieldList.Explicit<S extends FieldDescription>	A wrapper implementation of a field list for a given list of field descriptions.
FieldList.ForLoadedFields	An implementation of a field list for an array of loaded fields.
FieldList.ForTokens	A list of field descriptions for a list of detached tokens.
FieldList.TypeSubstituting	A list of field descriptions that yields FieldDescription.TypeSubstituting.
FieldLocator	A field locator offers an interface for locating a field that is declared by a specified type.
FieldLocator.AbstractBase	An abstract base implementation of a field locator.
FieldLocator.Factory	A factory for creating a FieldLocator.
FieldLocator.ForClassHierarchy	A field locator that looks up fields that are declared within a class's class hierarchy.
FieldLocator.ForClassHierarchy.Factory	A factory for creating a FieldLocator.ForClassHierarchy.
FieldLocator.ForExactType	A field locator that only looks up fields that are declared by a specific type.
FieldLocator.ForExactType.Factory	A factory for creating a FieldLocator.ForExactType.
FieldLocator.ForTopLevelType	A field locator that only locates fields in the top-level type.
FieldLocator.ForTopLevelType.Factory	A factory for locating a field in a top-level type.
FieldLocator.NoOp	A field locator that never discovers a field.
FieldLocator.Resolution	A resolution for a field lookup.
FieldLocator.Resolution.Illegal	An illegal resolution.
FieldLocator.Resolution.Simple	A simple implementation for a field resolution.
FieldManifestation	Describes the manifestation of a class's field, i.e.
FieldPersistence	Describes the persistence of a field, i.e.
FieldProxy	Using this annotation it is possible to access fields by getter and setter types.
FieldProxy.Binder	A binder for the FieldProxy annotation.
FieldProxy.Binder.FieldGetter	Implementation for a getter method.
FieldProxy.Binder.FieldResolver	A resolver for creating an instrumentation for a field access.
FieldProxy.Binder.FieldResolver.Factory	A factory for creating a field resolver.
FieldProxy.Binder.FieldResolver.Factory.Duplex	A duplex factory for a type that both sets and gets a field value.
FieldProxy.Binder.FieldResolver.Factory.Simplex	A simplex factory where field getters and setters both have their own type.
FieldProxy.Binder.FieldResolver.ForGetter	A field resolver for a getter accessor.
FieldProxy.Binder.FieldResolver.ForGetterSetterPair	A field resolver for an accessor that both gets and sets a field value.
FieldProxy.Binder.FieldResolver.ForSetter	A field resolver for a setter accessor.
FieldProxy.Binder.FieldResolver.Unresolved	An unresolved field resolver.
FieldProxy.Binder.FieldSetter	Implementation for a setter method.
FieldProxy.Binder.InstanceFieldConstructor	Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
FieldProxy.Binder.InstanceFieldConstructor.Appender	An appender for implementing an FieldProxy.Binder.InstanceFieldConstructor.
FieldProxy.Binder.StaticFieldConstructor	Represents an implementation for implementing a proxy type constructor when a static field is accessed.
FieldRegistry	A field registry represents an extendable collection of fields which are identified by their names that are mapped to a given FieldAttributeAppender.
FieldRegistry.Compiled	Represents a compiled field registry.
FieldRegistry.Compiled.NoOp	A no-op field registry that does not register annotations for any field.
FieldRegistry.Default	An immutable default implementation of a field registry.
FieldRegistry.Default.Compiled	A compiled default field registry.
FieldRegistry.Default.Compiled.Entry	An entry of a compiled field registry.
FieldRegistry.Default.Entry	An entry of the default field registry.
FieldTypeMatcher<T extends FieldDescription>	An element matcher that matches a field's type.
FieldValue	Assigns the value of a field of the instrumented type to the annotated parameter.
FieldValue.Binder	Binds a FieldValue annotation.
FieldValue.Binder.Delegate	A delegate implementation for the FieldValue.Binder.
FilterableList<T,S extends FilterableList<T,S>>	A filterable list allows to use an ElementMatcher to reduce a lists to elements that are matched by this matcher in this list.
FilterableList.AbstractBase<T,S extends FilterableList<T,S>>	A base implementation of a FilterableList.
FilterableList.Empty<T,S extends FilterableList<T,S>>	An implementation of an empty FilterableList.
FixedValue	This implementation returns a fixed value for a method.
FixedValue.AssignerConfigurable	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.
FixedValue.ForArgument	A fixed value implementation that returns a method's argument.
FixedValue.ForNullValue	A fixed value of null.
FixedValue.ForOriginType	A fixed value that appends the origin type of the instrumented type.
FixedValue.ForPoolValue	A fixed value implementation that represents its fixed value as a value that is written to the instrumented class's constant pool.
FixedValue.ForThisValue	A fixed value of this.
FixedValue.ForThisValue.Appender	A byte code appender for returning this.
FixedValue.ForValue	A fixed value implementation that represents its fixed value as a static field of the instrumented class.
FloatConstant	This class is responsible for loading any float constant onto the operand stack.
FloatConstant.ConstantPool	A stack manipulation for loading a float value from a class's constant pool onto the operand stack.
FramePaddingMethodVisitor	A method visitor that introduces padding using a Opcodes.NOP instruction if two frames a visited consecutively.
GenericTypeAwareAssigner	An assigner implementation that considers generic type assignability.
GenericTypeAwareAssigner.IsAssignableToVisitor	A visitor for generic types that determines assignability of such types.
GenericTypeAwareAssigner.IsAssignableToVisitor.OfGenericArray	A visitor for determining assignability of a generic array type.
GenericTypeAwareAssigner.IsAssignableToVisitor.OfManifestType	An implementation of a assignability visitor that is applicable for any non-wildcard type.
GenericTypeAwareAssigner.IsAssignableToVisitor.OfNonGenericType	A visitor for determining assignability of a non-generic type.
GenericTypeAwareAssigner.IsAssignableToVisitor.OfParameterizedType	A visitor for determining the assignability of a parameterized type.
GenericTypeAwareAssigner.IsAssignableToVisitor.OfSimpleType	A visitor for determining assignability of a type in a type hierarchy, i.e.
GenericTypeAwareAssigner.IsAssignableToVisitor.OfWildcard	A visitor to determine the assignability of a wildcard type.
GetSystemPropertyAction	An action for reading a system property as a privileged action.
HandleInvocation	An exact invocation of a method handle with a polymorphic signature.
HashCodeAndEqualsPlugin	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.
HashCodeAndEqualsPlugin.AnnotationOrderComparator	A comparator that arranges fields in the order of HashCodeAndEqualsPlugin.Sorted.
HashCodeAndEqualsPlugin.Enhance	Instructs the HashCodeAndEqualsPlugin to generate Object.hashCode() and Object.equals(Object) for the annotated class unless these methods are already declared explicitly.
HashCodeAndEqualsPlugin.Enhance.InvokeSuper	A strategy for determining the base value of a hash code or equality contract.
HashCodeAndEqualsPlugin.Sorted	Determines the sort order of fields for the equality check when implementing the Object.equals(Object) method.
HashCodeAndEqualsPlugin.ValueHandling	Determines how a field should be used within generated hash code and equality methods.
HashCodeAndEqualsPlugin.ValueHandling.Sort	Determines how a field should be handled.
HashCodeAndEqualsPlugin.ValueMatcher	An element matcher for a HashCodeAndEqualsPlugin.ValueHandling annotation.
HashCodeAndEqualsPlugin.WithNonNullableFields	A version of the HashCodeAndEqualsPlugin that assumes that all fields are non-nullable unless they are explicitly marked.
HashCodeMethod	An implementation of Object.hashCode() that takes a class's declared fields into consideration.
HashCodeMethod.Appender	A byte code appender to implement a hash code method.
HashCodeMethod.NullValueGuard	A guard against null values for fields with reference types.
HashCodeMethod.NullValueGuard.NoOp	A non-operational null value guard.
HashCodeMethod.NullValueGuard.UsingJump	A null value guard that expects a reference type and that uses a jump if a field value is null.
HashCodeMethod.OffsetProvider	An offset provider is responsible for supplying the initial hash code.
HashCodeMethod.OffsetProvider.ForFixedValue	An offset provider that supplies a fixed value.
HashCodeMethod.OffsetProvider.ForSuperMethodCall	An offset provider that invokes the super class's Object.hashCode() implementation.
HashCodeMethod.ValueTransformer	A value transformer that is responsible for resolving a field value to an int value.
HasSuperClassMatcher<T extends TypeDescription>	An element matcher that matches a super class.
HasSuperTypeMatcher<T extends TypeDescription>	An element matcher that matches a super type.
IgnoreForBinding	Indicates that a given target method should never be considered for binding to a source method.
IgnoreForBinding.Verifier	A non-instantiable type that allows to check if a method should be ignored for binding.
Implementation	An implementation is responsible for implementing methods of a dynamically created type as byte code.
Implementation.Composable	Represents an implementation that can be chained together with another implementation.
Implementation.Compound	A compound implementation that allows to combine several implementations.
Implementation.Compound.Composable	A compound implementation that allows to combine several implementations and that is Implementation.Composable.
Implementation.Context	The context for an implementation application.
Implementation.Context.Default	A default implementation of an Implementation.Context.ExtractableView which serves as its own MethodAccessorFactory.
Implementation.Context.Default.AbstractPropertyAccessorMethod	A base implementation of a method that accesses a property of an instrumented type.
Implementation.Context.Default.AccessorMethod	A description of an accessor method to access another method from outside the instrumented type.
Implementation.Context.Default.AccessorMethodDelegation	An implementation of a TypeWriter.MethodPool.Record for implementing an accessor method.
Implementation.Context.Default.CacheValueField	A description of a field that stores a cached value.
Implementation.Context.Default.DelegationRecord	An abstract method pool entry that delegates the implementation of a method to itself.
Implementation.Context.Default.Factory	A factory for creating a Implementation.Context.Default.
Implementation.Context.Default.FieldCacheEntry	A field cache entry for uniquely identifying a cached field.
Implementation.Context.Default.FieldGetter	A description of a field getter method.
Implementation.Context.Default.FieldGetterDelegation	An implementation for a field getter.
Implementation.Context.Default.FieldSetter	A description of a field setter method.
Implementation.Context.Default.FieldSetterDelegation	An implementation for a field setter.
Implementation.Context.Disabled	An implementation context that does not allow for any injections into the static initializer block.
Implementation.Context.Disabled.Factory	A factory for creating a Implementation.Context.Disabled.
Implementation.Context.ExtractableView	Represents an extractable view of an Implementation.Context which allows the retrieval of any registered auxiliary type.
Implementation.Context.ExtractableView.AbstractBase	An abstract base implementation of an extractable view of an implementation context.
Implementation.Context.Factory	A factory for creating a new implementation context.
Implementation.Simple	A simple implementation that does not register any members with the instrumented type.
Implementation.SpecialMethodInvocation	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.
Implementation.SpecialMethodInvocation.AbstractBase	An abstract base implementation of a valid special method invocation.
Implementation.SpecialMethodInvocation.Illegal	A canonical implementation of an illegal Implementation.SpecialMethodInvocation.
Implementation.SpecialMethodInvocation.Simple	A canonical implementation of a Implementation.SpecialMethodInvocation.
Implementation.Target	The target of an implementation.
Implementation.Target.AbstractBase	An abstract base implementation for an Implementation.Target.
Implementation.Target.AbstractBase.DefaultMethodInvocation	Determines if default method invocations are possible.
Implementation.Target.Factory	A factory for creating an Implementation.Target.
InheritedAnnotationMatcher<T extends TypeDescription>	An element matcher that matches the list of inherited annotations of a type description.
Initialization	Defines a configuration for a Maven build's type transformation.
InjectionClassLoader	An injection class loader allows for the injection of a class after the class loader was created.
InjectionClassLoader.Strategy	A class loading strategy for adding a type to an injection class loader.
InliningImplementationMatcher	A latent method matcher that identifies methods to instrument when redefining or rebasing a type.
Installer	An installer class which defined the hook-in methods that are required by the Java agent specification.
InstanceCheck	Implements an instanceof check.
InstanceTypeMatcher<T>	An element matcher that matches an object's type.
InstrumentedType	Implementations of this interface represent an instrumented type that is subject to change.
InstrumentedType.Default	A default implementation of an instrumented type.
InstrumentedType.Factory	A factory for creating an InstrumentedType.
InstrumentedType.Factory.Default	Default implementations of instrumented type factories.
InstrumentedType.Frozen	A frozen representation of an instrumented type of which the structure must not be modified.
InstrumentedType.Prepareable	Implementations are able to prepare an InstrumentedType.
InstrumentedType.WithFlexibleName	Implementations represent an InstrumentedType with a flexible name.
IntegerConstant	This class is responsible for loading any int constant onto the operand stack.
IntegerConstant.ConstantPool	A stack manipulation that loads a JVM-integer value from a constant pool value onto the operand stack.
IntegerConstant.SingleBytePush	A stack manipulation that loads a JVM-integer value by a BIPUSH operation which is legal for single byte integer values.
IntegerConstant.TwoBytePush	A stack manipulation that loads a JVM-integer value by a SIPUSH operation which is legal for up to two byte integer values.
InvocationHandlerAdapter	An adapter for adapting an InvocationHandler.
InvocationHandlerAdapter.AssignerConfigurable	Allows for the configuration of an Assigner of an InvocationHandlerAdapter.
InvocationHandlerAdapter.ForField	An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in an instance field.
InvocationHandlerAdapter.ForInstance	An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in a static field.
InvocationHandlerAdapter.WithoutPrivilegeConfiguration	Allows the configuration of privileged lookup for the resolution of Method constants that are provided to the invocation handler.
InvokeDynamic	An implementation that applies a dynamic method invocation.
InvokeDynamic.AbstractDelegator	An abstract delegator that allows to specify a configuration for any specification of an argument.
InvokeDynamic.InvocationProvider	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.
InvokeDynamic.InvocationProvider.ArgumentProvider	An argument provider is responsible for loading arguments to a bootstrapped method onto the operand stack and providing the types of these arguments.
InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper	Represents wrapper types and types that could be stored in a class's constant pool as such constant pool values.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanConstant	An argument provider for a boolean value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant	An argument provider for a byte value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant	An argument provider for a char value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant	An argument provider for a Class constant.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant	An argument provider for a double value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue	An argument provider for an Enum constant.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField	Provides an argument from an existing field.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.WithExplicitType	An argument provider for a field value with an explicit type.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatConstant	An argument provider for a float value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstance	An argument provider for a value that is stored in a randomly named static field.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerConstant	An argument provider for a int value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodInstanceAndParameters	An argument provider that loads a reference to the intercepted instance and all arguments of the intercepted method.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodParameters	An argument provider that loads all arguments of the intercepted method.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant	An argument provider for a Java instance.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant	An argument provider for a long value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter	An argument provider that loads an argument of the intercepted method.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.WithExplicitType	An argument provider for a method parameter with an explicit type.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue	An argument provider for the null value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant	An argument provider for a short value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant	An argument provider for a String value.
InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance	An argument provider that loads the intercepted instance.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	A resolved InvokeDynamic.InvocationProvider.ArgumentProvider.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple	A simple implementation of a resolved argument provider.
InvokeDynamic.InvocationProvider.Default	An invocation provider that requests a synthetic dynamic invocation where all arguments are explicitly provided by the user.
InvokeDynamic.InvocationProvider.Default.Target	A target for a synthetically bound method call.
InvokeDynamic.InvocationProvider.NameProvider	Provides the name of the method that is to be bound by a dynamic method call.
InvokeDynamic.InvocationProvider.NameProvider.ForExplicitName	A name provider that provides an explicit name.
InvokeDynamic.InvocationProvider.NameProvider.ForInterceptedMethod	A name provider that provides the name of the intercepted method.
InvokeDynamic.InvocationProvider.ReturnTypeProvider	Provides the return type that is requested from the bootstrap method.
InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForExplicitType	Requests an explicit return type.
InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForInterceptedMethod	Requests the return type of the intercepted method.
InvokeDynamic.InvocationProvider.Target	A target for a dynamic method invocation.
InvokeDynamic.InvocationProvider.Target.Resolved	Represents a resolved InvokeDynamic.InvocationProvider.Target.
InvokeDynamic.InvocationProvider.Target.Resolved.Simple	A simple implementation of InvokeDynamic.InvocationProvider.Target.Resolved.
InvokeDynamic.TerminationHandler	A termination handler is responsible to handle the return value of a method that is invoked via a InvokeDynamic.
InvokeDynamic.WithImplicitArguments	Representation of an InvokeDynamic implementation where the bootstrapped method is passed a this reference, if available, and any arguments of the instrumented method.
InvokeDynamic.WithImplicitTarget	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.
InvokeDynamic.WithImplicitType	An InvokeDynamic invocation where the last argument is assigned its implicit type.
InvokeDynamic.WithImplicitType.OfArgument	An invoke dynamic implementation where the last argument is an implicitly typed method argument.
InvokeDynamic.WithImplicitType.OfField	An invoke dynamic implementation where the last argument is an implicitly typed field value.
InvokeDynamic.WithImplicitType.OfInstance	A step in the invoke dynamic domain specific language that allows to explicitly specify a field type for a reference value.
IsNamedMatcher<T extends NamedElement.WithOptionalName>	An element matcher that matches a named element only if is explicitly named.
JavaConstant	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.
JavaConstant.Dynamic	Represents a dynamically resolved constant pool entry of a class file.
JavaConstant.MethodHandle	Represents a java.lang.invoke.MethodHandle object.
JavaConstant.MethodHandle.Dispatcher	A dispatcher for analyzing a java.lang.invoke.MethodHandle instance.
JavaConstant.MethodHandle.Dispatcher.AbstractBase	An abstract base implementation of a dispatcher.
JavaConstant.MethodHandle.Dispatcher.CreationAction	A creation action for a dispatcher.
JavaConstant.MethodHandle.Dispatcher.ForJava7CapableVm	A dispatcher that extracts the information of a method handle by using private APIs that are available in Java 7+.
JavaConstant.MethodHandle.Dispatcher.ForJava8CapableVm	A dispatcher for introspecting a java.lang.invoke.MethodHandle instance on a virtual machine that officially supports this introspection, i.e.
JavaConstant.MethodHandle.Dispatcher.ForLegacyVm	A dispatcher that does not support method handles at all.
JavaConstant.MethodHandle.Dispatcher.Initializable	An initializable version of a dispatcher that is not yet made accessible.
JavaConstant.MethodHandle.HandleType	A representation of a method handle's type.
JavaConstant.MethodType	Represents a java.lang.invoke.MethodType object.
JavaConstant.MethodType.Dispatcher	A dispatcher for extracting information from a java.lang.invoke.MethodType instance.
JavaConstant.MethodType.Dispatcher.CreationAction	A creation action for a dispatcher.
JavaConstant.MethodType.Dispatcher.ForJava7CapableVm	A dispatcher for virtual machines that are aware of the java.lang.invoke.MethodType type that was added in Java version 7.
JavaConstant.MethodType.Dispatcher.ForLegacyVm	A dispatcher for virtual machines that are not aware of the java.lang.invoke.MethodType type that was added in Java version 7.
JavaConstantValue	A constant representing a JavaConstant.
JavaModule	Type-safe representation of a java.lang.Module.
JavaModule.Dispatcher	A dispatcher for accessing the java.lang.Module API if it is available on the current VM.
JavaModule.Dispatcher.CreationAction	A creation action for a dispatcher.
JavaModule.Dispatcher.Disabled	A disabled dispatcher for a VM that does not support the java.lang.Module API.
JavaModule.Dispatcher.Enabled	A dispatcher for a VM that does support the java.lang.Module API.
JavaModule.Dispatcher.Enabled.WithInstrumentationSupport	A dispatcher for a VM that does support the java.lang.Module API and that supports Instrumentation.
JavaModule.Dispatcher.Enabled.WithoutInstrumentationSupport	A dispatcher for a VM that does support the java.lang.Module API and that does not support Instrumentation.
JavaType	Representations of Java types that do not exist in Java 6 but that have a special meaning to the JVM.
LambdaFactory	This class serves as a dispatcher for creating lambda expression objects when Byte Buddy is configured to instrument the java.lang.invoke.LambdaMetafactory.
LatentMatcher<T>	A latent matcher that resolves an ElementMatcher after supplying a type description.
LatentMatcher.Conjunction<S>	A matcher that computes the conjunction of all supplied latent matchers.
LatentMatcher.Disjunction<S>	A matcher that computes the disjunction of all supplied latent matchers.
LatentMatcher.ForFieldToken	A latent matcher where the field token is being attached to the supplied type description before matching.
LatentMatcher.ForFieldToken.ResolvedMatcher	A resolved matcher of a latent field matcher for a field token.
LatentMatcher.ForMethodToken	A latent matcher where the method token is being attached to the supplied type description before matching.
LatentMatcher.ForMethodToken.ResolvedMatcher	A resolved matcher of a latent method matcher for a method token.
LatentMatcher.ForRecordComponentToken	A latent matcher for a record component token.
LatentMatcher.ForSelfDeclaredMethod	A latent matching methods that are declared by the resolved type.
LatentMatcher.Resolved<S>	A latent matcher representing an already resolved ElementMatcher.
LineNumberPrependingMethodVisitor	A method visitor that maps the first available line number information, if available, to the beginning of the method.
LoadedTypeInitializer	Implementations of this interface explicitly initialize a loaded type.
LoadedTypeInitializer.Compound	A compound loaded type initializer that combines several type initializers.
LoadedTypeInitializer.ForStaticField	A type initializer for setting a value for a static field.
LoadedTypeInitializer.NoOp	A loaded type initializer that does not do anything.
LocalVariableAwareMethodVisitor	A method visitor that traces the amount of used local variable slots.
LongConstant	This class is responsible for loading any long constant onto the operand stack.
LongConstant.ConstantPool	A stack manipulation for loading a long value from a class's constant pool onto the operand stack.
Mandate	Indicates if a member is mandated.
MavenCoordinate	A Maven coordinate.
MemberAttributeExtension<T>	A visitor that adds attributes to a class member.
MemberAttributeExtension.ForField	A visitor that adds attributes to a field.
MemberAttributeExtension.ForField.FieldAttributeVisitor	A field visitor to apply an field attribute appender.
MemberAttributeExtension.ForMethod	A visitor that adds attributes to a method.
MemberAttributeExtension.ForMethod.AttributeAppendingMethodVisitor	A method visitor to apply a method attribute appender.
MemberRemoval	A visitor wrapper that removes fields or methods that match a given ElementMatcher.
MemberRemoval.MemberRemovingClassVisitor	A class visitor that removes members based on element matchers.
MemberSubstitution	Substitutes field access or method invocations within a method's body.
MemberSubstitution.Replacement	A replacement combines a MemberSubstitution.Substitution and a way of choosing if this substitution should be applied for a discovered member.
MemberSubstitution.Replacement.Binding	A binding for a replacement of a field or method access within another method.
MemberSubstitution.Replacement.Binding.Resolved	A binding that was resolved for an actual substitution.
MemberSubstitution.Replacement.Binding.Unresolved	An unresolved binding.
MemberSubstitution.Replacement.Factory	A factory for creating a replacement for an instrumented method.
MemberSubstitution.Replacement.Factory.Compound	A compound factory.
MemberSubstitution.Replacement.ForElementMatchers	A replacement that substitutes a member based on a row of element matchers.
MemberSubstitution.Replacement.ForElementMatchers.Factory	A factory for creating a replacement that chooses members based on a row of element matchers.
MemberSubstitution.Replacement.ForFirstBinding	A replacement that only resolves the first matching replacement of a list of replacements.
MemberSubstitution.Replacement.InvocationType	Describes a method invocation type.
MemberSubstitution.Replacement.NoOp	A non-operational replacement.
MemberSubstitution.SubstitutingMethodVisitor	A method visitor that applies a substitution for matched methods.
MemberSubstitution.Substitution	A substitution replaces or enhances an interaction with a field or method within an instrumented method.
MemberSubstitution.Substitution.Chain	A substitution chain allows for chaining multiple substitution steps for a byte code element being replaced.
MemberSubstitution.Substitution.Chain.Factory	A factory for creating a substitution chain.
MemberSubstitution.Substitution.Chain.Step	Represents a step of a substitution chain.
MemberSubstitution.Substitution.Chain.Step.Factory	Resolves a substitution for an instrumented method.
MemberSubstitution.Substitution.Chain.Step.Resolution	A resolved substitution step.
MemberSubstitution.Substitution.Chain.Step.Simple	A simple substitution step within a substitution chain.
MemberSubstitution.Substitution.Factory	A factory for creating a substitution for an instrumented method.
MemberSubstitution.Substitution.ForFieldAccess	A substitution with a field access.
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver	A method resolver for locating a field for a substitute.
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.ForElementMatcher	A field matcher that resolves a non-static field on the first parameter type of the substituted member usage.
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.Simple	A simple field resolver that returns a specific field.
MemberSubstitution.Substitution.ForFieldAccess.OfGivenField	A factory for a substitution that substitutes with a given field.
MemberSubstitution.Substitution.ForFieldAccess.OfMatchedField	A factory for a substitution that locates a field on the receiver type using a matcher.
MemberSubstitution.Substitution.ForMethodInvocation	A substitution with a method invocation.
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver	A method resolver for locating a method for a substitute.
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Matching	A method resolver that locates a non-static method by locating it from the receiver type.
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Simple	A simple method resolver that returns a given method.
MemberSubstitution.Substitution.ForMethodInvocation.OfGivenMethod	A factory for a substitution that invokes a given method.
MemberSubstitution.Substitution.ForMethodInvocation.OfInstrumentedMethod	A factory for a substitution that invokes the instrumented method.
MemberSubstitution.Substitution.ForMethodInvocation.OfMatchedMethod	A factory for a substitution that locates a method on the receiver type using a matcher.
MemberSubstitution.Substitution.Stubbing	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.
MemberSubstitution.TypePoolResolver	A type pool resolver is responsible for resolving a TypePool for locating substituted members.
MemberSubstitution.TypePoolResolver.ForClassFileLocator	A type pool resolver that resolves the implicit pool but additionally checks another class file locator.
MemberSubstitution.TypePoolResolver.ForExplicitPool	A type pool resolver that returns a specific type pool.
MemberSubstitution.TypePoolResolver.OfImplicitPool	Returns the implicit type pool.
MemberSubstitution.WithoutSpecification	A member substitution that lacks a specification for how to substitute the matched members references within a method body.
MemberSubstitution.WithoutSpecification.ForMatchedByteCodeElement	Describes a member substitution that requires a specification for how to replace a byte code element.
MemberSubstitution.WithoutSpecification.ForMatchedField	Describes a member substitution that requires a specification for how to replace a field.
MemberSubstitution.WithoutSpecification.ForMatchedMethod	Describes a member substitution that requires a specification for how to replace a method or constructor.
MetadataAwareClassVisitor	A class visitor that traces invocations of visitation methods and notifies if a nest host or outer class was not visited.
MethodAccessorFactory	A factory for creating method proxies for an auxiliary type.
MethodAccessorFactory.AccessType	Indicates the type of access to an accessor method.
MethodAccessorFactory.Illegal	A method accessor factory that forbids any accessor registration.
MethodArguments	Describes if a method allows varargs arguments.
MethodAttributeAppender	An appender that writes attributes or annotations to a given ASM MethodVisitor.
MethodAttributeAppender.Compound	A method attribute appender that combines several method attribute appenders to be represented as a single method attribute appender.
MethodAttributeAppender.Explicit	Appends an annotation to a method or method parameter.
MethodAttributeAppender.Explicit.Target	Represents the target on which this method attribute appender should write its annotations to.
MethodAttributeAppender.Explicit.Target.OnMethod	A method attribute appender target for writing annotations directly onto the method.
MethodAttributeAppender.Explicit.Target.OnMethodParameter	A method attribute appender target for writing annotations onto a given method parameter.
MethodAttributeAppender.Factory	A factory that creates method attribute appenders for a given type.
MethodAttributeAppender.Factory.Compound	A method attribute appender factory that combines several method attribute appender factories to be represented as a single factory.
MethodAttributeAppender.ForInstrumentedMethod	Implementation of a method attribute appender that writes all annotations of the instrumented method to the method that is being created.
MethodAttributeAppender.ForReceiverType	A method attribute appender that writes a receiver type.
MethodAttributeAppender.NoOp	A method attribute appender that does not append any attributes.
MethodCall	This Implementation allows the invocation of a specified method while providing explicit arguments to this method.
MethodCall.ArgumentLoader	An argument loader is responsible for loading an argument for an invoked method onto the operand stack.
MethodCall.ArgumentLoader.ArgumentProvider	An argument provider is responsible for providing an argument loader for each argument to supply to a method.
MethodCall.ArgumentLoader.Factory	A factory that produces MethodCall.ArgumentLoaders for a given instrumented method.
MethodCall.ArgumentLoader.ForField	Loads the value of an existing field onto the operand stack.
MethodCall.ArgumentLoader.ForField.ArgumentProvider	An argument provider for a field access.
MethodCall.ArgumentLoader.ForField.Factory	A factory for an argument loaded that loads the value of an existing field as an argument.
MethodCall.ArgumentLoader.ForInstance	Loads a value onto the operand stack that is stored in a static field.
MethodCall.ArgumentLoader.ForInstance.Factory	A factory that supplies the value of a static field as an argument.
MethodCall.ArgumentLoader.ForInstrumentedType	Loads the instrumented type onto the operand stack.
MethodCall.ArgumentLoader.ForInstrumentedType.Factory	A factory for an argument loader that supplies the instrumented type as an argument.
MethodCall.ArgumentLoader.ForMethodCall	Loads the return value of a method call onto the operand stack.
MethodCall.ArgumentLoader.ForMethodCall.ArgumentProvider	An argument provider for a method call.
MethodCall.ArgumentLoader.ForMethodCall.Factory	A factory for an argument loaded that loads the return value of a method call as an argument.
MethodCall.ArgumentLoader.ForMethodParameter	Loads a parameter of the instrumented method onto the operand stack.
MethodCall.ArgumentLoader.ForMethodParameter.Factory	A factory for an argument loader that supplies a method parameter as an argument.
MethodCall.ArgumentLoader.ForMethodParameter.OfInstrumentedMethod	A factory for argument loaders that supplies all arguments of the instrumented method as arguments.
MethodCall.ArgumentLoader.ForMethodParameterArray	Loads an array containing all arguments of a method.
MethodCall.ArgumentLoader.ForMethodParameterArray.ForInstrumentedMethod	A factory that creates an arguments loader that loads all parameters of the instrumented method contained in an array.
MethodCall.ArgumentLoader.ForMethodParameterArrayElement	An argument loader that loads an element of a parameter of an array type.
MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod	An argument loader factory that loads an array element from a parameter for each argument of the invoked method.
MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter	Creates an argument loader for an array element that of a specific parameter.
MethodCall.ArgumentLoader.ForNullConstant	An argument loader that loads the null value onto the operand stack.
MethodCall.ArgumentLoader.ForStackManipulation	Loads a stack manipulation resulting in a specific type as an argument.
MethodCall.ArgumentLoader.ForThisReference	An argument loader that assigns the this reference to a parameter.
MethodCall.ArgumentLoader.ForThisReference.Factory	A factory for an argument loader that supplies the this value as an argument.
MethodCall.FieldSetting	A MethodCall that sets the call's result as the value of a field.
MethodCall.FieldSetting.Appender	A byte code appender to implement a field-setting method call.
MethodCall.MethodInvoker	A method invoker is responsible for creating a method invocation that is to be applied by a MethodCall.
MethodCall.MethodInvoker.Factory	A factory for creating a method invoker.
MethodCall.MethodInvoker.ForContextualInvocation	Applies a contextual invocation of the provided method, i.e.
MethodCall.MethodInvoker.ForContextualInvocation.Factory	A factory for creating a contextual method invoker.
MethodCall.MethodInvoker.ForDefaultMethodInvocation	Invokes a method as a Java 8 default method.
MethodCall.MethodInvoker.ForDefaultMethodInvocation.Factory	A factory for creating a method invoker for a default method invocation.
MethodCall.MethodInvoker.ForSuperMethodInvocation	Applies a super method invocation of the provided method.
MethodCall.MethodInvoker.ForSuperMethodInvocation.Factory	A method invoker factory for a super method invocation.
MethodCall.MethodInvoker.ForVirtualInvocation	Applies a virtual invocation on a given type.
MethodCall.MethodInvoker.ForVirtualInvocation.Factory	A method invoker factory for a virtual method invocation.
MethodCall.MethodInvoker.ForVirtualInvocation.WithImplicitType	A method invoker for a virtual method that uses an implicit target type.
MethodCall.MethodLocator	A method locator is responsible for identifying the method that is to be invoked by a MethodCall.
MethodCall.MethodLocator.Factory	A factory for creating a method locator.
MethodCall.MethodLocator.ForElementMatcher	A method locator that identifies a unique virtual method.
MethodCall.MethodLocator.ForElementMatcher.Factory	A factory for a method locator that uses a matcher on the instrumented type's available methods for identifing a target method.
MethodCall.MethodLocator.ForExplicitMethod	Invokes a given method.
MethodCall.MethodLocator.ForInstrumentedMethod	A method locator that simply returns the intercepted method.
MethodCall.TargetHandler	A target handler is responsible for invoking a method for a MethodCall.
MethodCall.TargetHandler.Factory	A factory for creating a target handler.
MethodCall.TargetHandler.ForConstructingInvocation	Invokes a method in order to construct a new instance.
MethodCall.TargetHandler.ForConstructingInvocation.Factory	A target handler factory for a constructor invocation.
MethodCall.TargetHandler.ForField	Creates a target handler that stores the instance to invoke a method on in an instance field.
MethodCall.TargetHandler.ForField.Factory	A factory for a field access.
MethodCall.TargetHandler.ForField.Location	A location of a field.
MethodCall.TargetHandler.ForField.Location.ForExplicitField	An explicit field location.
MethodCall.TargetHandler.ForField.Location.ForImplicitField	An implicit field location.
MethodCall.TargetHandler.ForMethodCall	A target handler that executes the method and uses it's return value as the target object.
MethodCall.TargetHandler.ForMethodCall.Factory	Creates a factory for invoking a method on the return type of another method.
MethodCall.TargetHandler.ForMethodCall.Resolved	A resolved target handler for a method call.
MethodCall.TargetHandler.ForMethodParameter	A target handler that loads the parameter of the given index as the target object.
MethodCall.TargetHandler.ForMethodParameter.Resolved	A resolved target handler for a method parameter.
MethodCall.TargetHandler.ForSelfOrStaticInvocation	A target handler that invokes a method either on the instance of the instrumented type or as a static method.
MethodCall.TargetHandler.ForSelfOrStaticInvocation.Factory	A factory for invoking a static method or a self-declared method.
MethodCall.TargetHandler.ForSelfOrStaticInvocation.Resolved	A resolved target handler for a static or self-declared invocation.
MethodCall.TargetHandler.ForValue	A target handler that invokes a method on an instance that is stored in a static field.
MethodCall.TargetHandler.ForValue.Factory	A factory for a target handler that loads a specific value.
MethodCall.TargetHandler.Resolved	A resolved target handler.
MethodCall.TargetHandler.Simple	A simple target handler that applies a given stack manipulation.
MethodCall.TerminationHandler	A termination handler is responsible to handle the return value of a method that is invoked via a MethodCall.
MethodCall.TerminationHandler.Factory	A factory for creating a termination handler.
MethodCall.TerminationHandler.FieldSetting	A termination handler that sets a field.
MethodCall.TerminationHandler.FieldSetting.Explicit	A factory for a field-setting termination handler that locates a given field.
MethodCall.TerminationHandler.FieldSetting.Implicit	A factory for a field-setting termination handler that uses a matcher to locate the target field on the insturmented type.
MethodCall.TerminationHandler.Simple	Simple termination handler implementations.
MethodCall.WithoutSpecifiedTarget	Represents a MethodCall that invokes a method without specifying an invocation method.
MethodCallProxy	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.
MethodCallProxy.AssignableSignatureCall	A stack manipulation that creates a MethodCallProxy for a given method an pushes such an object onto the call stack.
MethodCallProxy.ConstructorCall	An implementation for a constructor of a MethodCallProxy.
MethodCallProxy.ConstructorCall.Appender	The appender for implementing the MethodCallProxy.ConstructorCall.
MethodCallProxy.MethodCall	An implementation for a method of a MethodCallProxy.
MethodCallProxy.PrecomputedMethodGraph	A precomputed method graph that only displays the methods that are relevant for creating a method call proxy.
MethodConstant	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.
MethodConstant.CachedConstructor	Represents a cached constructor for a MethodConstant.
MethodConstant.CachedMethod	Represents a cached method for a MethodConstant.
MethodConstant.CanCache	Represents a MethodConstant that is directly loaded onto the operand stack without caching the value.
MethodConstant.CanCacheIllegal	Represents a method constant that cannot be represented by Java's reflection API.
MethodConstant.ForConstructor	Creates a MethodConstant for loading a Constructor instance onto the operand stack.
MethodConstant.ForMethod	Creates a MethodConstant for loading a Method instance onto the operand stack.
MethodConstant.PrivilegedLookup	Performs a privileged lookup of a method constant by using an AccessController.
MethodDelegation	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.
MethodDelegation.Appender	The appender for implementing a MethodDelegation.
MethodDelegation.ImplementationDelegate	An implementation delegate is responsible for executing the actual method delegation and for resolving the target methods.
MethodDelegation.ImplementationDelegate.Compiled	A compiled implementation delegate.
MethodDelegation.ImplementationDelegate.Compiled.ForConstruction	A compiled implementation delegate for a constructor delegation.
MethodDelegation.ImplementationDelegate.Compiled.ForField	A compiled implementation delegate that invokes methods on a field.
MethodDelegation.ImplementationDelegate.Compiled.ForMethodReturn	A compiled implementation delegate that invokes a method on an instance that is returned by another method.
MethodDelegation.ImplementationDelegate.Compiled.ForStaticCall	A compiled implementation delegate for invoking a static method.
MethodDelegation.ImplementationDelegate.ForConstruction	An implementation delegate for constructing an instance.
MethodDelegation.ImplementationDelegate.ForField	An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.
MethodDelegation.ImplementationDelegate.ForField.WithInstance	An implementation target for a static field that is declared by the instrumented type and that is assigned an instance.
MethodDelegation.ImplementationDelegate.ForField.WithLookup	An implementation target for a field that is declared by the instrumented type or a super type.
MethodDelegation.ImplementationDelegate.ForMethodReturn	An implementation delegate for invoking a delegation target on the another methods return value.
MethodDelegation.ImplementationDelegate.ForStaticMethod	An implementation delegate for a static method delegation.
MethodDelegation.WithCustomProperties	A MethodDelegation with custom configuration.
MethodDelegationBinder	A method delegation binder is responsible for creating a method binding for a source method to a target method.
MethodDelegationBinder.AmbiguityResolver	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.
MethodDelegationBinder.AmbiguityResolver.Compound	A chain of MethodDelegationBinder.AmbiguityResolvers that are applied in the given order until two bindings can be resolved.
MethodDelegationBinder.AmbiguityResolver.Directional	An ambiguity resolver that always resolves in the specified direction.
MethodDelegationBinder.AmbiguityResolver.NoOp	An ambiguity resolver that does not attempt to resolve a conflicting binding.
MethodDelegationBinder.AmbiguityResolver.Resolution	A resolution state of an attempt to resolve two conflicting bindings.
MethodDelegationBinder.BindingResolver	A binding resolver is responsible to choose a method binding between several possible candidates.
MethodDelegationBinder.BindingResolver.Default	A default implementation of a binding resolver that fully relies on an MethodDelegationBinder.AmbiguityResolver.
MethodDelegationBinder.BindingResolver.StreamWriting	Binds a method using another resolver and prints the selected binding to a PrintStream.
MethodDelegationBinder.BindingResolver.Unique	A binding resolver that only binds a method if it has a unique binding.
MethodDelegationBinder.MethodBinding	A binding attempt created by a MethodDelegationBinder.
MethodDelegationBinder.MethodBinding.Builder	A mutable builder that allows to compose a MethodDelegationBinder.MethodBinding by adding parameter bindings incrementally.
MethodDelegationBinder.MethodBinding.Builder.Build	A method binding that was created by a MethodDelegationBinder.MethodBinding.Builder.
MethodDelegationBinder.MethodBinding.Illegal	Representation of an attempt to bind a source method to a target method that is not applicable.
MethodDelegationBinder.MethodInvoker	Implementations are used as delegates for invoking a method that was bound using a MethodDelegationBinder.
MethodDelegationBinder.MethodInvoker.Simple	A simple method invocation that merely uses the most general form of method invocation as provided by MethodInvocation.
MethodDelegationBinder.MethodInvoker.Virtual	A method invocation that enforces a virtual invocation that is dispatched on a given type.
MethodDelegationBinder.ParameterBinding<T>	A binding attempt for a single parameter.
MethodDelegationBinder.ParameterBinding.Anonymous	An anonymous binding of a target method parameter.
MethodDelegationBinder.ParameterBinding.Illegal	A singleton representation of an illegal binding for a method parameter.
MethodDelegationBinder.ParameterBinding.Unique<T>	A uniquely identifiable parameter binding for a target method.
MethodDelegationBinder.Processor	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.
MethodDelegationBinder.Record	A method delegation that was compiled to a target method.
MethodDelegationBinder.Record.Illegal	A compiled method delegation binder that only yields illegal bindings.
MethodDelegationBinder.TerminationHandler	A termination handler is responsible for terminating a method delegation.
MethodDelegationBinder.TerminationHandler.Default	Responsible for creating a StackManipulation that is applied after the interception method is applied.
MethodDescription	Implementations of this interface describe a Java method, i.e.
MethodDescription.AbstractBase	An abstract base implementation of a method description.
MethodDescription.ForLoadedConstructor	An implementation of a method description for a loaded constructor.
MethodDescription.ForLoadedMethod	An implementation of a method description for a loaded method.
MethodDescription.InDefinedShape	Represents a method in its defined shape, i.e.
MethodDescription.InDefinedShape.AbstractBase	An abstract base implementation of a method description in its defined shape.
MethodDescription.InGenericShape	Represents a method description in its generic shape, i.e.
MethodDescription.Latent	A latent method description describes a method that is not attached to a declaring TypeDescription.
MethodDescription.Latent.TypeInitializer	A method description that represents the type initializer.
MethodDescription.SignatureToken	A token representing a method's name and raw return and parameter types.
MethodDescription.Token	A token representing a method's properties detached from a type.
MethodDescription.TypeSubstituting	A method description that represents a given method but with substituted method types.
MethodDescription.TypeToken	A token representing a method's erased return and parameter types.
MethodExceptionTypeMatcher<T extends MethodDescription>	An element matcher that matches the exceptions that are declared by a method.
MethodGraph	A method graph represents a view on a set of methods as they are seen from a given type.
MethodGraph.Compiler	A compiler to produce a MethodGraph from a given type.
MethodGraph.Compiler.AbstractBase	An abstract base implementation of a method graph compiler.
MethodGraph.Compiler.Default<T>	A default implementation of a method graph.
MethodGraph.Compiler.Default.Harmonizer<S>	A harmonizer is responsible for creating a token that identifies a method's relevant attributes for considering two methods of being equal or not.
MethodGraph.Compiler.Default.Harmonizer.ForJavaMethod	A harmonizer for the Java programming language that identifies a method by its parameter types only.
MethodGraph.Compiler.Default.Harmonizer.ForJavaMethod.Token	A token that identifies a Java method's type by its parameter types only.
MethodGraph.Compiler.Default.Harmonizer.ForJVMMethod	A harmonizer for the Java virtual machine's method dispatching rules that identifies a method by its parameter types and return type.
MethodGraph.Compiler.Default.Harmonizer.ForJVMMethod.Token	A token that identifies a Java method's type by its parameter types and return type.
MethodGraph.Compiler.Default.Key<S>	A key represents a collection of methods within a method graph to later yield a node representing a collection of methods, i.e.
MethodGraph.Compiler.Default.Key.Detached	A detached version of a key that identifies methods by their JVM signature, i.e.
MethodGraph.Compiler.Default.Key.Harmonized<V>	A harmonized key represents a key where equality is decided based on tokens that are returned by a MethodGraph.Compiler.Default.Harmonizer.
MethodGraph.Compiler.Default.Key.Store<V>	A store for collected methods that are identified by keys.
MethodGraph.Compiler.Default.Key.Store.Entry<W>	An entry of a key store.
MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous<U>	An entry representing an ambiguous node resolution.
MethodGraph.Compiler.Default.Key.Store.Entry.Ambiguous.Node	A node implementation representing an ambiguous method resolution.
MethodGraph.Compiler.Default.Key.Store.Entry.Initial<U>	An entry in its initial state before registering any method as a representative.
MethodGraph.Compiler.Default.Key.Store.Entry.Resolved<U>	An entry representing a non-ambiguous node resolution.
MethodGraph.Compiler.Default.Key.Store.Entry.Resolved.Node	A node implementation representing a non-ambiguous method.
MethodGraph.Compiler.Default.Key.Store.Graph	A graph implementation based on a key store.
MethodGraph.Compiler.Default.Merger	Implementations are responsible for identifying a representative method for a MethodGraph.Node between several ambiguously resolved methods.
MethodGraph.Compiler.Default.Merger.Directional	A directional merger that always returns either the left or right method description.
MethodGraph.Compiler.ForDeclaredMethods	A flat compiler that simply returns the methods that are declared by the instrumented type.
MethodGraph.Empty	A canonical implementation of an empty method graph.
MethodGraph.Linked	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.
MethodGraph.Linked.Delegation	A simple implementation of a linked method graph that exposes views by delegation to given method graphs.
MethodGraph.Node	Represents a node within a method graph.
MethodGraph.Node.Simple	A simple implementation of a resolved node of a method without bridges.
MethodGraph.Node.Sort	Represents a MethodGraph.Node's state.
MethodGraph.Node.Unresolved	A canonical implementation of an unresolved node.
MethodGraph.NodeList	A list of nodes.
MethodGraph.Simple	A simple implementation of a method graph.
MethodInvocation	A builder for a method invocation.
MethodInvocation.HandleInvocation	Performs a method invocation on a method handle with a polymorphic type signature.
MethodInvocation.HandleType	The type of method handle invocation.
MethodInvocation.IllegalInvocation	An illegal implicit method invocation.
MethodInvocation.OfGenericMethod	A method invocation of a generically resolved method.
MethodInvocation.WithImplicitInvocationTargetType	Represents a method invocation where the invocation type (static, virtual, special, interface) is derived from the given method's description.
MethodList<T extends MethodDescription>	Implementations represent a list of method descriptions.
MethodList.AbstractBase<S extends MethodDescription>	A base implementation of a MethodList.
MethodList.Empty<S extends MethodDescription>	An implementation of an empty method list.
MethodList.Explicit<S extends MethodDescription>	A method list that is a wrapper for a given list of method descriptions.
MethodList.ForLoadedMethods	A method list implementation that returns all loaded byte code methods (methods and constructors) that are declared for a given type.
MethodList.ForTokens	A list of method descriptions for a list of detached tokens.
MethodList.TypeSubstituting	A list of method descriptions that yields MethodDescription.TypeSubstituting.
MethodManifestation	Describes the manifestation of a method, i.e.
MethodNameEqualityResolver	Implementation of an MethodDelegationBinder.AmbiguityResolver that resolves conflicting bindings by considering equality of a target method's internalName as an indicator for a dominant binding.
MethodNameTransformer	A method name transformer provides a unique mapping of a method's name to an alternative name.
MethodNameTransformer.Prefixing	A method name transformer that adds a fixed prefix to an original method name.
MethodNameTransformer.Suffixing	A method name transformer that adds a fixed suffix to an original method name, separated by a $.
MethodOverrideMatcher<T extends MethodDescription>	A matcher that checks if any super type of a type declares a method with the same shape of a matched method.
MethodParametersMatcher<T extends MethodDescription>	An element matcher that matches a method's parameters.
MethodParameterTypeMatcher<T extends ParameterDescription>	An element matcher that matches a method's parameter's type.
MethodParameterTypesMatcher<T extends ParameterList<?>>	An element matcher that matches a method's parameter types.
MethodRebaseResolver	A method rebase resolver is responsible for mapping methods of an instrumented type to an alternative signature.
MethodRebaseResolver.Default	A default implementation of a method rebase resolver.
MethodRebaseResolver.Disabled	A method rebase resolver that preserves any method in its original form.
MethodRebaseResolver.Resolution	A resolution for a method that was checked by a MethodRebaseResolver.
MethodRebaseResolver.Resolution.ForRebasedConstructor	A MethodRebaseResolver.Resolution of a rebased constructor.
MethodRebaseResolver.Resolution.ForRebasedConstructor.RebasedConstructor	An description of a rebased constructor.
MethodRebaseResolver.Resolution.ForRebasedMethod	A MethodRebaseResolver.Resolution of a rebased method.
MethodRebaseResolver.Resolution.ForRebasedMethod.RebasedMethod	A description of a rebased method.
MethodRebaseResolver.Resolution.Preserved	A MethodRebaseResolver.Resolution of a non-rebased method.
MethodRegistry	A method registry is responsible for storing information on how a method is intercepted.
MethodRegistry.Compiled	A compiled version of a method registry.
MethodRegistry.Default	A default implementation of a method registry.
MethodRegistry.Default.Compiled	A compiled version of a default method registry.
MethodRegistry.Default.Compiled.Entry	An entry of a compiled method registry.
MethodRegistry.Default.Entry	An entry of a default method registry.
MethodRegistry.Default.Prepared	A prepared version of a default method registry.
MethodRegistry.Default.Prepared.Entry	An entry of a prepared method registry.
MethodRegistry.Handler	A handler for implementing a method.
MethodRegistry.Handler.Compiled	A compiled handler for implementing a method.
MethodRegistry.Handler.ForAbstractMethod	A handler for defining an abstract or native method.
MethodRegistry.Handler.ForAnnotationValue	A handler for defining a default annotation value for a method.
MethodRegistry.Handler.ForImplementation	A handler for a method that is implemented as byte code.
MethodRegistry.Handler.ForImplementation.Compiled	A compiled handler for implementing a method.
MethodRegistry.Handler.ForVisibilityBridge	A handler for implementing a visibility bridge.
MethodRegistry.Handler.ForVisibilityBridge.Compiled	A compiled handler for a visibility bridge handler.
MethodRegistry.Prepared	A method registry that fully prepared the instrumented type.
MethodReturn	A stack manipulation returning a value of a given type.
MethodReturnTypeMatcher<T extends MethodDescription>	An element matcher that matches its argument's return type against a given type matcher.
MethodSortMatcher<T extends MethodDescription>	Matches a method description by its general characteristics which are represented as a MethodSortMatcher.Sort.
MethodSortMatcher.Sort	Represents a specific characteristic of a method description.
MethodStrictness	A modifier contributor to determine the use of strictfp on a method.
MethodVariableAccess	A stack assignment that loads a method variable from a given index of the local variable array.
MethodVariableAccess.MethodLoading	A stack manipulation that loads all parameters of a given method onto the operand stack.
MethodVariableAccess.MethodLoading.TypeCastingHandler	A type casting handler allows a type transformation of all arguments of a method after loading them onto the operand stack.
MethodVariableAccess.MethodLoading.TypeCastingHandler.ForBridgeTarget	A type casting handler that casts all parameters of a method to the parameter types of a compatible method with covariant parameter types.
MethodVariableAccess.MethodLoading.TypeCastingHandler.NoOp	A non-operative type casting handler.
MethodVariableAccess.OffsetIncrementing	A stack manipulation that increments an integer variable.
ModifierAdjustment	A visitor wrapper that adjusts the modifiers of the instrumented type or its members.
ModifierAdjustment.Adjustment<T>	A description of a conditional adjustment.
ModifierAdjustment.ModifierAdjustingClassVisitor	A class visitor that enforces a collection of modifier adjustments.
ModifierContributor	An element that describes a type modifier as described in the JVMS.
ModifierContributor.ForField	A marker interface for modifiers that can be applied to fields.
ModifierContributor.ForMethod	A marker interface for modifiers that can be applied to methods.
ModifierContributor.ForParameter	A marker interface for modifiers that can be applied to method parameters.
ModifierContributor.ForType	A marker interface for modifiers that can be applied to types.
ModifierContributor.Resolver<T extends ModifierContributor>	A resolver for Java modifiers represented by ModifierContributors.
ModifierMatcher<T extends ModifierReviewable>	An element matcher that matches a byte code element by its modifiers.
ModifierMatcher.Mode	Determines the type of modifier to be matched by a ModifierMatcher.
ModifierReviewable	Implementations of this interface can be described in terms of a Java modifier.
ModifierReviewable.AbstractBase	An abstract base implementation of a ModifierReviewable class.
ModifierReviewable.ForFieldDescription	A modifier reviewable for a FieldDescription.
ModifierReviewable.ForMethodDescription	A modifier reviewable for a MethodDescription.
ModifierReviewable.ForParameterDescription	A modifier reviewable for a ParameterDescription.
ModifierReviewable.ForTypeDefinition	A modifier reviewable for a TypeDescription.
ModifierReviewable.OfAbstraction	A modifier reviewable for a byte code element that can be abstract, i.e.
ModifierReviewable.OfByteCodeElement	A modifier reviewable for a ByteCodeElement, i.e.
ModifierReviewable.OfEnumeration	A modifier reviewable for a byte code element that can represent an enumeration, i.e.
Morph	This annotation instructs Byte Buddy to inject a proxy class that calls a method's super method with explicit arguments.
Morph.Binder	A binder for the Morph annotation.
Morph.Binder.DefaultMethodLocator	A default method locator is responsible for looking up a default method to a given source method.
Morph.Binder.DefaultMethodLocator.Explicit	An explicit default method locator attempts to look up a default method in the specified interface type.
Morph.Binder.DefaultMethodLocator.Implicit	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.
Morph.Binder.RedirectionProxy	A proxy that implements the installed interface in order to allow for a morphed super method invocation.
Morph.Binder.RedirectionProxy.InstanceFieldConstructor	Creates an instance of the proxy when instrumenting an instance method.
Morph.Binder.RedirectionProxy.InstanceFieldConstructor.Appender	The byte code appender that implements the constructor.
Morph.Binder.RedirectionProxy.MethodCall	Implements a the method call of the morphing method.
Morph.Binder.RedirectionProxy.StaticFieldConstructor	Creates an instance of the proxy when instrumenting a static method.
MultipleParentClassLoader	This ClassLoader is capable of loading classes from multiple parents.
MultipleParentClassLoader.Builder	A builder to collect class loader and that creates a MultipleParentClassLoader only if multiple or no ClassLoaders are found in the process.
MultipleParentClassLoader.CompoundEnumeration	A compound URL enumeration.
Multiplication	A stack manipulation that multiplies two numbers on the operand stack.
NamedElement	Represents a Java element with a name.
NamedElement.WithDescriptor	A named element with a class file descriptor and a generic signature.
NamedElement.WithGenericName	A named element with a generic type name.
NamedElement.WithOptionalName	Describes a named element where naming the element is optional and an alternative default name is provided if no explicit name is given.
NamedElement.WithRuntimeName	A named element with a name that has a particular meaning to the Java runtime.
NameMatcher<T extends NamedElement>	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.
NamingStrategy	A naming strategy for determining a fully qualified name for a dynamically created Java type.
NamingStrategy.AbstractBase	An abstract base implementation where the names of redefined and rebased types are retained.
NamingStrategy.PrefixingRandom	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.
NamingStrategy.SuffixingRandom	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.
NamingStrategy.SuffixingRandom.BaseNameResolver	A base name resolver is responsible for resolving a name onto which the suffix is appended.
NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue	A base name resolver that simply returns a fixed value.
NamingStrategy.SuffixingRandom.BaseNameResolver.ForGivenType	Uses a specific type's name as the resolved name.
NamingStrategy.SuffixingRandom.BaseNameResolver.ForUnnamedType	Uses the unnamed type's super type's name as the resolved name.
NegatingMatcher<T>	An element matcher that reverses the matching result of another matcher.
Nexus	This nexus is a global dispatcher for initializing classes with LoadedTypeInitializers.
NexusAccessor	The Nexus accessor is creating a VM-global singleton Nexus such that it can be seen by all class loaders of a virtual machine.
NexusAccessor.Dispatcher	A dispatcher for registering type initializers in the Nexus.
NexusAccessor.Dispatcher.Available	An enabled dispatcher for registering a type initializer in a Nexus.
NexusAccessor.Dispatcher.CreationAction	Creates a new dispatcher for accessing a Nexus.
NexusAccessor.Dispatcher.Unavailable	A disabled dispatcher where a Nexus is not available.
NexusAccessor.InitializationAppender	An initialization appender that looks up a loaded type initializer from Byte Buddy's Nexus.
NoOpClassFileTransformer	A class file transformer that does not apply a transformation.
NullConstant	Represents a stack manipulation to load a null pointer onto the operand stack.
NullMatcher<T>	An element matcher that matches the null value.
OpenedClassReader	A ClassReader that does not apply a class file version check if the net.bytebuddy.experimental property is set.
Origin	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:
Origin.Binder	A binder for binding parameters that are annotated with Origin.
Ownership	Determines the ownership of a field or method, i.e.
PackageDefinitionStrategy	A package definer is responsible for defining a package's properties when a class of a new package is loaded.
PackageDefinitionStrategy.Definition	A definition of a package.
PackageDefinitionStrategy.Definition.Simple	A simple package definition where any property is represented by a value.
PackageDefinitionStrategy.Definition.Trivial	A package definer that defines packages without any meta data.
PackageDefinitionStrategy.Definition.Undefined	A canonical implementation of an undefined package.
PackageDefinitionStrategy.ManifestReading	A package definer that reads a class loader's manifest file.
PackageDefinitionStrategy.ManifestReading.SealBaseLocator	A locator for a seal base URL.
PackageDefinitionStrategy.ManifestReading.SealBaseLocator.ForFixedValue	A seal base locator that seals all packages with a fixed URL.
PackageDefinitionStrategy.ManifestReading.SealBaseLocator.ForTypeResourceUrl	A seal base locator that imitates the behavior of a URLClassLoader, i.e.
PackageDefinitionStrategy.ManifestReading.SealBaseLocator.NonSealing	A seal base locator that never seals a package.
PackageDefinitionStrategy.NoOp	A package definer that does not define any package.
PackageDefinitionStrategy.Trivial	A package definer that only defines packages without any meta data.
PackageDescription	A package description represents a Java package.
PackageDescription.AbstractBase	An abstract base implementation of a package description.
PackageDescription.ForLoadedPackage	Represents a loaded Package wrapped as a PackageDescription.
PackageDescription.Simple	A simple implementation of a package without annotations.
ParameterDescription	Description of the parameter of a Java method or constructor.
ParameterDescription.AbstractBase	A base implementation of a method parameter description.
ParameterDescription.ForLoadedParameter<T extends java.lang.reflect.AccessibleObject>	Description of a loaded parameter with support for the information exposed by java.lang.reflect.Parameter.
ParameterDescription.ForLoadedParameter.Dispatcher	A dispatcher creating parameter descriptions based on the API that is available for the current JVM.
ParameterDescription.ForLoadedParameter.Dispatcher.CreationAction	A creation action for a dispatcher.
ParameterDescription.ForLoadedParameter.Dispatcher.ForJava8CapableVm	A dispatcher for VMs that support the java.lang.reflect.Parameter API for Java 8+.
ParameterDescription.ForLoadedParameter.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM that does not know the java.lang.reflect.Parameter type that only throws exceptions on any property extraction.
ParameterDescription.ForLoadedParameter.OfConstructor	A description of a loaded Constructor parameter for a modern VM.
ParameterDescription.ForLoadedParameter.OfLegacyVmConstructor	Description of a loaded constructor's parameter on a virtual machine where java.lang.reflect.Parameter is not available.
ParameterDescription.ForLoadedParameter.OfLegacyVmMethod	Description of a loaded method's parameter on a virtual machine where java.lang.reflect.Parameter is not available.
ParameterDescription.ForLoadedParameter.OfMethod	A description of a loaded Method parameter for a modern VM.
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource	A source for querying parameter annotations.
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedConstructor	A source for a loaded constructor.
ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedMethod	A source for a loaded method.
ParameterDescription.InDefinedShape	Represents a parameter in its defined shape, i.e.
ParameterDescription.InDefinedShape.AbstractBase	An abstract base implementation of a parameter description in its defined shape.
ParameterDescription.InGenericShape	Represents a parameter description in its generic shape, i.e.
ParameterDescription.Latent	A latent description of a parameter that is not attached to a method or constructor.
ParameterDescription.Token	A token representing a parameter's properties detached from a type.
ParameterDescription.Token.TypeList	A list of types represented as a list of parameter tokens.
ParameterDescription.TypeSubstituting	A parameter description that represents a given parameter but with a substituted parameter type.
ParameterLengthResolver	This MethodDelegationBinder.AmbiguityResolver selects the method with more arguments.
ParameterList<T extends ParameterDescription>	Represents a list of parameters of a method or a constructor.
ParameterList.AbstractBase<S extends ParameterDescription>	An base implementation for a ParameterList.
ParameterList.Empty<S extends ParameterDescription>	An empty list of parameters.
ParameterList.Explicit<S extends ParameterDescription>	A list of explicitly provided parameter descriptions.
ParameterList.Explicit.ForTypes	A parameter list representing parameters without meta data or annotations.
ParameterList.ForLoadedExecutable<T>	Represents a list of parameters for an executable, i.e.
ParameterList.ForLoadedExecutable.Dispatcher	A dispatcher for creating descriptions of parameter lists and for evaluating the size of an java.lang.reflect.Executable's parameters.
ParameterList.ForLoadedExecutable.Dispatcher.CreationAction	A creation action for a dispatcher.
ParameterList.ForLoadedExecutable.Dispatcher.ForJava8CapableVm	A dispatcher for a legacy VM that does support the java.lang.reflect.Parameter type.
ParameterList.ForLoadedExecutable.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM that does not support the java.lang.reflect.Parameter type.
ParameterList.ForLoadedExecutable.OfConstructor	Describes the list of Constructor parameters on a modern VM.
ParameterList.ForLoadedExecutable.OfLegacyVmConstructor	Represents a list of constructor parameters on virtual machines where the java.lang.reflect.Parameter type is not available.
ParameterList.ForLoadedExecutable.OfLegacyVmMethod	Represents a list of method parameters on virtual machines where the java.lang.reflect.Parameter type is not available.
ParameterList.ForLoadedExecutable.OfMethod	Describes the list of Method parameters on a modern VM.
ParameterList.ForTokens	A list of parameter descriptions for a list of detached tokens.
ParameterList.TypeSubstituting	A list of parameter descriptions that yields ParameterDescription.TypeSubstituting.
ParameterManifestation	Indicates whether a parameter was denoted as final or not.
Pipe	A target method parameter that is annotated with this annotation allows to forward an intercepted method invocation to another instance.
Pipe.Binder	A TargetMethodAnnotationDrivenBinder.ParameterBinder for binding the Pipe annotation.
Pipe.Binder.Redirection	An auxiliary type for performing the redirection of a method invocation as requested by the Pipe annotation.
Pipe.Binder.Redirection.ConstructorCall	The implementation to implement a Pipe.Binder.Redirection's constructor.
Pipe.Binder.Redirection.ConstructorCall.Appender	The appender for implementing the Pipe.Binder.Redirection.ConstructorCall.
Pipe.Binder.Redirection.MethodCall	The implementation to implement a Pipe.Binder.Redirection's forwarding method.
Plugin	A plugin that allows for the application of Byte Buddy transformations during a build process.
Plugin.Engine	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.
Plugin.Engine.AbstractBase	An abstract base implementation of a plugin engine.
Plugin.Engine.Default	A default implementation of a plugin engine.
Plugin.Engine.Dispatcher	A dispatcher to execute a plugin engine transformation.
Plugin.Engine.Dispatcher.Factory	A factory that is used for creating a dispatcher that is used for a specific plugin engine application.
Plugin.Engine.Dispatcher.ForParallelTransformation	A dispatcher that applies transformations within one or more threads in parallel to the default transformer.
Plugin.Engine.Dispatcher.ForParallelTransformation.EagerWork	An eager materialization that does not defer processing after preprocessing.
Plugin.Engine.Dispatcher.ForParallelTransformation.Factory	A factory for a dispatcher that uses a given executor service for parallel dispatching.
Plugin.Engine.Dispatcher.ForParallelTransformation.WithThrowawayExecutorService	A parallel dispatcher that shuts down its executor service upon completion of a plugin engine's application.
Plugin.Engine.Dispatcher.ForParallelTransformation.WithThrowawayExecutorService.Factory	A factory for a parallel executor service that creates a new executor service on each plugin engine application.
Plugin.Engine.Dispatcher.ForSerialTransformation	A dispatcher that applies transformation upon discovery.
Plugin.Engine.Dispatcher.ForSerialTransformation.Factory	A factory for creating a serial dispatcher.
Plugin.Engine.Dispatcher.Materializable	The result of a work assignment that needs to be invoked from the main thread that triggers a dispatchers life-cycle methods.
Plugin.Engine.Dispatcher.Materializable.ForFailedElement	A materializable for an element that failed to be transformed.
Plugin.Engine.Dispatcher.Materializable.ForRetainedElement	A materializable for an element that is retained in its original state.
Plugin.Engine.Dispatcher.Materializable.ForTransformedElement	A materializable for a successfully transformed type.
Plugin.Engine.Dispatcher.Materializable.ForUnresolvedElement	A materializable for an element that could not be resolved.
Plugin.Engine.ErrorHandler	An error handler that is used during a plugin engine application.
Plugin.Engine.ErrorHandler.Compound	A compound error handler.
Plugin.Engine.ErrorHandler.Enforcing	An error handler that enforces certain properties of the transformation.
Plugin.Engine.ErrorHandler.Failing	An implementation of an error handler that fails the plugin engine application.
Plugin.Engine.Listener	A listener that is invoked upon any event during a plugin engine application.
Plugin.Engine.Listener.Adapter	An adapter that implements all methods non-operational.
Plugin.Engine.Listener.Compound	A compound listener.
Plugin.Engine.Listener.ForErrorHandler	A listener decorator that forwards events to an error handler if they are applicable.
Plugin.Engine.Listener.NoOp	A non-operational listener.
Plugin.Engine.Listener.StreamWriting	A listener that forwards significant events of a plugin engine application to a PrintStream.
Plugin.Engine.Listener.WithErrorsOnly	A decorator for another listener to only print error events.
Plugin.Engine.Listener.WithTransformationsOnly	A decorator for another listener to only print transformation and error events.
Plugin.Engine.PoolStrategy	A pool strategy determines the creation of a TypePool for a plugin engine application.
Plugin.Engine.PoolStrategy.Default	A default implementation of a pool strategy where type descriptions are resolved lazily.
Plugin.Engine.PoolStrategy.Eager	A pool strategy that resolves type descriptions eagerly.
Plugin.Engine.Source	A source for a plugin engine provides binary elements to consider for transformation.
Plugin.Engine.Source.Element	Represents a binary element found in a source location.
Plugin.Engine.Source.Element.ForByteArray	An element representation for a byte array.
Plugin.Engine.Source.Element.ForFile	An element representation for a file.
Plugin.Engine.Source.Element.ForJarEntry	Represents a jar file entry as an element.
Plugin.Engine.Source.Empty	An empty source that does not contain any elements or a manifest.
Plugin.Engine.Source.Filtering	A source that applies a filter upon iterating elements.
Plugin.Engine.Source.ForFolder	Represents the contents of a folder as class files.
Plugin.Engine.Source.ForJarFile	Represents a jar file as a source.
Plugin.Engine.Source.InMemory	A source that represents a collection of in-memory resources that are represented as byte arrays.
Plugin.Engine.Source.InMemory.MapEntryIterator	An iterator that represents map entries as sources.
Plugin.Engine.Source.Origin	An origin for elements.
Plugin.Engine.Source.Origin.Filtering	An origin that forwards all invocations to a delegate where an ElementMatcher is applied prior to iteration.
Plugin.Engine.Source.Origin.Filtering.FilteringIterator	An iterator that applies a filter to observed elements.
Plugin.Engine.Source.Origin.ForJarFile	An origin implementation for a jar file.
Plugin.Engine.Summary	A summary of the application of a Plugin.Engine to a source and target.
Plugin.Engine.Target	A target for a plugin engine represents a sink container for all elements that are supplied by a Plugin.Engine.Source.
Plugin.Engine.Target.Discarding	A sink that discards any entry.
Plugin.Engine.Target.ForFolder	Represents a folder as the target for a plugin engine's application.
Plugin.Engine.Target.ForFolder.Dispatcher	A dispatcher that allows for file copy operations based on NIO2 if available.
Plugin.Engine.Target.ForFolder.Dispatcher.CreationAction	An action for creating a dispatcher.
Plugin.Engine.Target.ForFolder.Dispatcher.ForJava7CapableVm	A dispatcher for VMs that are capable of NIO2.
Plugin.Engine.Target.ForFolder.Dispatcher.ForLegacyVm	A legacy dispatcher that is not capable of NIO.
Plugin.Engine.Target.ForJarFile	Represents a jar file as a target.
Plugin.Engine.Target.InMemory	A sink that stores all elements in a memory map.
Plugin.Engine.Target.Sink	A sink represents an active writing process.
Plugin.Engine.Target.Sink.ForJarOutputStream	Implements a sink for a jar file.
Plugin.Engine.TypeStrategy	A type strategy determines the transformation that is applied to a type description.
Plugin.Engine.TypeStrategy.Default	Default implementations for type strategies.
Plugin.Engine.TypeStrategy.ForEntryPoint	A type strategy that represents a given EntryPoint for a build tool.
Plugin.Factory	A factory for providing a build plugin.
Plugin.Factory.Simple	A simple factory that returns a preconstructed plugin instance..
Plugin.Factory.UsingReflection	A plugin factory that uses reflection for instantiating a plugin.
Plugin.Factory.UsingReflection.ArgumentResolver	Allows to resolve arguments for a Plugin constructor.
Plugin.Factory.UsingReflection.ArgumentResolver.ForIndex	An argument resolver that resolves an argument for a specific parameter index.
Plugin.Factory.UsingReflection.ArgumentResolver.ForIndex.WithDynamicType	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.
Plugin.Factory.UsingReflection.ArgumentResolver.ForType<T>	An argument resolver that resolves parameters for a given type.
Plugin.Factory.UsingReflection.ArgumentResolver.NoOp	An argument resolver that never resolves an argument.
Plugin.Factory.UsingReflection.ArgumentResolver.Resolution	A resolution provided by an argument provider.
Plugin.Factory.UsingReflection.ArgumentResolver.Resolution.Resolved	Represents a resolved argument resolution.
Plugin.Factory.UsingReflection.ArgumentResolver.Resolution.Unresolved	Represents an unresolved argument resolution.
Plugin.Factory.UsingReflection.Instantiator	An instantiator is responsible for invoking a plugin constructor reflectively.
Plugin.Factory.UsingReflection.Instantiator.Resolved	An instantiator that is resolved for a given constructor with arguments.
Plugin.Factory.UsingReflection.Instantiator.Unresolved	An instantiator that is not resolved for creating an instance.
Plugin.Factory.UsingReflection.Priority	Indicates that a constructor should be treated with a given priority if several constructors can be resolved.
Plugin.ForElementMatcher	An abstract base for a Plugin that matches types by a given ElementMatcher.
Plugin.NoOp	A non-operational plugin that does not instrument any type.
Plugin.WithPreprocessor	A plugin that applies a preprocessor, i.e.
PluginArgument	Describes an argument to a Plugin constuctor.
PrimitiveBoxingDelegate	This delegate is responsible for boxing a primitive types to their wrapper equivalents.
PrimitiveTypeAwareAssigner	This assigner is able to handle non-void, primitive types.
PrimitiveTypeMatcher<T extends TypeDefinition>	Matches a primitive type.
PrimitiveUnboxingDelegate	This delegate is responsible for unboxing a wrapper type to their primitive equivalents.
PrimitiveUnboxingDelegate.ExplicitlyTypedUnboxingResponsible	An explicitly types unboxing responsible is applied for directly unboxing a wrapper type.
PrimitiveUnboxingDelegate.ImplicitlyTypedUnboxingResponsible	An unboxing responsible for an implicitly typed value.
PrimitiveUnboxingDelegate.UnboxingResponsible	Implementations represent an unboxing delegate that is able to perform the unboxing operation.
PrimitiveWideningDelegate	This delegate is responsible for widening a primitive type to represent a larger primitive type.
PrimitiveWideningDelegate.WideningStackManipulation	A stack manipulation that widens a primitive type into a more general primitive type.
PrivilegedMemberLookupAction	A PrivilegedExceptionAction to lookup a method constant using an AccessController.
ProvisioningState	Describes if a method parameter is mandated, i.e.
RandomString	A provider of randomized String values.
RebaseDynamicTypeBuilder<T>	A type builder that rebases an instrumented type.
RebaseImplementationTarget	An implementation target for redefining a given type while preserving the original methods within the instrumented type.
RebaseImplementationTarget.Factory	A factory for creating a RebaseImplementationTarget.
RebaseImplementationTarget.RebasedMethodInvocation	A Implementation.SpecialMethodInvocation which invokes a rebased method as given by a MethodRebaseResolver.
RecordComponentAttributeAppender	An appender that writes attributes or annotations to a given ASM RecordComponentVisitor.
RecordComponentAttributeAppender.Compound	A record component attribute appender that combines several method attribute appenders to be represented as a single record component attribute appender.
RecordComponentAttributeAppender.Explicit	Appends an annotation to a record component.
RecordComponentAttributeAppender.Factory	A factory that creates record component attribute appenders for a given type.
RecordComponentAttributeAppender.Factory.Compound	A record component attribute appender factory that combines several record component attribute appender factories to be represented as a single factory.
RecordComponentAttributeAppender.ForInstrumentedRecordComponent	An attribute appender that writes all annotations that are declared on a record component.
RecordComponentAttributeAppender.NoOp	A record component attribute appender that does not append any attributes.
RecordComponentDescription	Represents a component of a Java record.
RecordComponentDescription.AbstractBase	An abstract base implementation for a record component description.
RecordComponentDescription.ForLoadedRecordComponent	Represents a loaded record component.
RecordComponentDescription.ForLoadedRecordComponent.Dispatcher	A dispatcher for resolving a java.lang.reflect.RecordComponent.
RecordComponentDescription.ForLoadedRecordComponent.Dispatcher.CreationAction	A creation action for creating a dispatcher.
RecordComponentDescription.ForLoadedRecordComponent.Dispatcher.ForJava14CapableVm	A dispatcher for a Java 14-capable JVM.
RecordComponentDescription.ForLoadedRecordComponent.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM that does not support records.
RecordComponentDescription.InDefinedShape	A description of a record component in its defined shape.
RecordComponentDescription.InDefinedShape.AbstractBase	An abstract base implementation of a record component description in its defined shape.
RecordComponentDescription.InGenericShape	A description of a record component in generic shape.
RecordComponentDescription.Latent	A latent record component description.
RecordComponentDescription.Token	A token representing a record component's properties detached from a type.
RecordComponentDescription.TypeSubstituting	A type substituting representation of a record component description.
RecordComponentList<T extends RecordComponentDescription>	Implementations represent a list of record component descriptions.
RecordComponentList.AbstractBase<S extends RecordComponentDescription>	An abstract base implementation of a list of record components.
RecordComponentList.Empty<S extends RecordComponentDescription>	An empty list of record components.
RecordComponentList.Explicit<S extends RecordComponentDescription>	A wrapper implementation of an explicit list of record components.
RecordComponentList.ForLoadedRecordComponents	A list of loaded record components.
RecordComponentList.ForTokens	A list of record components described as tokens.
RecordComponentList.TypeSubstituting	A type-substituting list of record component descriptions.
RecordComponentRegistry	A record component registry represents an extendable collection of record components which are identified by their names that are mapped to a given RecordComponentAttributeAppender.
RecordComponentRegistry.Compiled	Represents a compiled record component registry.
RecordComponentRegistry.Compiled.NoOp	A no-op record component registry that does not register annotations for any record component.
RecordComponentRegistry.Default	An immutable default implementation of a record component registry.
RecordComponentRegistry.Default.Compiled	A compiled default record component registry.
RecordComponentRegistry.Default.Compiled.Entry	An entry of a compiled record component registry.
RecordComponentRegistry.Default.Entry	An entry of the default record component registry.
RecordMatcher<T extends TypeDefinition>	Matches a record.
RedefinitionDynamicTypeBuilder<T>	A type builder that redefines an instrumented type.
ReferenceTypeAwareAssigner	A simple assigner that is capable of handling the casting of reference types.
Removal	Removes a value from the operand stack.
ResettableClassFileTransformer	A class file transformer that can reset its transformation.
ResettableClassFileTransformer.AbstractBase	An abstract base implementation of a ResettableClassFileTransformer.
ResettableClassFileTransformer.WithDelegation	Implements a resettable class file transformer that allows for the delegation of a transformation.
RuntimeType	Parameters that are annotated with this annotation will be assigned by also considering the runtime type of the target parameter.
RuntimeType.Verifier	A non-instantiable type that allows to check if a method or parameter should consider a runtime type.
SerializedConstant	A constant that represents a value in its serialized form.
SetAccessibleAction<T extends java.lang.reflect.AccessibleObject>	An action for making an AccessibleObject accessible.
SignatureTokenMatcher<T extends MethodDescription>	Matches a method description's signature token against another matcher.
StackAwareMethodVisitor	A method visitor that is aware of the current size of the operand stack at all times.
StackManipulation	Describes a manipulation of a method's operand stack that does not affect the frame's variable array.
StackManipulation.Compound	An immutable stack manipulation that aggregates a sequence of other stack manipulations.
StackManipulation.Illegal	Canonical representation of an illegal stack manipulation.
StackManipulation.Size	A description of the size change that is imposed by some StackManipulation.
StackManipulation.Trivial	Canonical representation of a legal stack manipulation which does not require any action.
StackSize	Represents the size of a Java type on the operand stack.
StreamDrainer	A utility for draining the contents of an InputStream into a byte array.
StringMatcher	An element matcher that compares two strings by a given pattern which is characterized by a StringMatcher.Mode.
StringMatcher.Mode	Defines the mode a StringMatcher compares to strings with.
StringSetMatcher	An element matcher which checks if a string is in a set of strings.
StubMethod	This implementation creates a method stub which does nothing but returning the default value of the return type of the method.
StubValue	A stub value represents the (boxed) default value of the intercepted method's return type.
StubValue.Binder	Binds the StubValue annotation.
SubclassDynamicTypeBuilder<T>	A type builder that creates an instrumented type as a subclass, i.e.
SubclassDynamicTypeBuilder.InstrumentableMatcher	A matcher that locates all methods that are overridable and not ignored or that are directly defined on the instrumented type.
SubclassImplementationTarget	An implementation target for creating a subclass of a given type.
SubclassImplementationTarget.Factory	A factory for creating a SubclassImplementationTarget.
SubclassImplementationTarget.OriginTypeResolver	Responsible for identifying the origin type that an implementation target represents when Implementation.Target.getOriginType() is invoked.
SubTypeMatcher<T extends TypeDescription>	An element matcher that matches its argument for being another type's subtype.
Super	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.
Super.Binder	A binder for handling the Super annotation.
Super.Binder.TypeLocator	Locates the type which should be the base type of the created proxy.
Super.Binder.TypeLocator.ForInstrumentedType	A type locator that yields the instrumented type.
Super.Binder.TypeLocator.ForParameterType	A type locator that yields the target parameter's type.
Super.Binder.TypeLocator.ForType	A type locator that returns a given type.
Super.Instantiation	Determines the instantiation of the proxy type.
SuperCall	Parameters that are annotated with this annotation will be assigned a proxy for calling the instrumented method's super implementation.
SuperCall.Binder	A binder for handling the SuperCall annotation.
SuperMethod	A parameter with this annotation is assigned an instance of Method which invokes the super implementation of this method.
SuperMethod.Binder	A binder for the SuperMethod annotation.
SuperMethod.Binder.DelegationMethod	Loads the delegation method constant onto the stack.
SuperMethodCall	This implementation will create a new method which simply calls its super method.
SuperMethodCall.Appender	An appender for implementing a SuperMethodCall.
SuperMethodCall.Appender.TerminationHandler	A handler that determines how to handle the method return value.
SuperMethodCall.WithoutReturn	A super method invocation where the return value is dropped instead of returning from the method.
SuperTypeMatcher<T extends TypeDescription>	An element matcher that matches its argument for being another type's super type.
SynchronizationState	Describes if a method is supposed to be synchronized.
SyntheticState	Defines if a type or member is supposed to be marked as synthetic.
TargetMethodAnnotationDrivenBinder	This MethodDelegationBinder binds method by analyzing annotations found on the target method that is subject to a method binding.
TargetMethodAnnotationDrivenBinder.DelegationProcessor	A delegation processor is a helper class for a TargetMethodAnnotationDrivenBinder for performing its actual logic.
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler	A handler is responsible for processing a parameter's binding.
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Bound<T extends java.lang.annotation.Annotation>	A bound handler represents an unambiguous parameter binder that was located for a given array of annotations.
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound	An unbound handler is a fallback for returning an illegal binding for parameters for which no parameter binder could be located.
TargetMethodAnnotationDrivenBinder.DelegationProcessor.Handler.Unbound.DefaultArgument	A default implementation of an Argument annotation.
TargetMethodAnnotationDrivenBinder.ParameterBinder<T extends java.lang.annotation.Annotation>	A parameter binder is used as a delegate for binding a parameter according to a particular annotation type found on this parameter.
TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFieldBinding<S extends java.lang.annotation.Annotation>	A parameter binder that binds a field's value.
TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue<S extends java.lang.annotation.Annotation>	Implements a parameter binder that binds a fixed value to a parameter with a given annotation.
TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue.OfConstant<U extends java.lang.annotation.Annotation>	A parameter binder that binds a fixed value to a parameter annotation when using a MethodDelegation.
TargetMethodAnnotationDrivenBinder.Record	A compiled record of a target method annotation-driven binder.
TargetType	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.
TextConstant	Represents a String value that is stored in a type's constant pool.
This	Parameters that are annotated with this annotation will be assigned a reference to the instrumented object, if the instrumented method is not static.
This.Binder	A binder for handling the This annotation.
Throw	Throws a Throwable which must lie on top of the stack when this stack manipulation is called.
ToStringMethod	An implementation of Object.toString() that concatenates the String representation of all fields that are declared by a class.
ToStringMethod.Appender	An appender to implement ToStringMethod.
ToStringMethod.PrefixResolver	A prefix resolver is responsible for providing a value that is prepended to a Object.toString() implementation.
ToStringMethod.PrefixResolver.Default	Default implementations for a prefix resolver.
ToStringMethod.PrefixResolver.ForFixedValue	A prefix resolver that returns a fixed value.
ToStringMethod.ValueConsumer	A value consumer that is responsible for adding a field value to the string creating StringBuilder.
ToStringPlugin	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.
ToStringPlugin.Enhance	Instructs the ToStringPlugin to generate a Object.toString() method for the annotated class unless this method is already declared explicitly.
ToStringPlugin.Enhance.Prefix	A strategy for defining a prefix.
ToStringPlugin.Exclude	Determines that the annotated field is excluded from a string representation of the ToStringPlugin.
Transformation	A transformation specification to apply during the plugin's execution.
Transformer<T>	A transformer is responsible for transforming an object into a compatible instance of the same type.
Transformer.Compound<S>	A compound transformer.
Transformer.ForField	A transformer for a field that delegates to another transformer that transforms a FieldDescription.Token.
Transformer.ForField.FieldModifierTransformer	A transformer for a field's modifiers.
Transformer.ForField.TransformedField	An implementation of a transformed field.
Transformer.ForMethod	A transformer for a field that delegates to another transformer that transforms a MethodDescription.Token.
Transformer.ForMethod.MethodModifierTransformer	A transformer for a method's modifiers.
Transformer.ForMethod.TransformedMethod	The transformed method.
Transformer.NoOp	A non-operational transformer that returns the received instance.
TrivialType	A trivial type that extends Object without defining any fields, methods or constructors.
TypeAttributeAppender	An appender that writes attributes or annotations to a given ASM ClassVisitor.
TypeAttributeAppender.Compound	A compound type attribute appender that concatenates a number of other attribute appenders.
TypeAttributeAppender.Explicit	An attribute appender that appends a single annotation to a given type.
TypeAttributeAppender.ForInstrumentedType	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.
TypeAttributeAppender.ForInstrumentedType.Differentiating	A type attribute appender that writes all annotations of the instrumented but excludes annotations up to a given index.
TypeAttributeAppender.NoOp	A type attribute appender that does not append any attributes.
TypeCache<T>	A cache for storing types without strongly referencing any class loader or type.
TypeCache.LookupKey	A key used for looking up a previously inserted class loader cache.
TypeCache.SimpleKey	A simple key based on a collection of types where no type is strongly referenced.
TypeCache.Sort	Determines the storage format for a cached type.
TypeCache.StorageKey	A key used for storing a class loader cache reference.
TypeCache.WithInlineExpunction<S>	An implementation of a TypeCache where obsolete references are cleared upon any call.
TypeCasting	A stack manipulation for a type down casting.
TypeConstantAdjustment	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.
TypeConstantAdjustment.TypeConstantDissolvingClassVisitor	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.
TypeConstantAdjustment.TypeConstantDissolvingClassVisitor.TypeConstantDissolvingMethodVisitor	A method visitor that remaps class constants to invocations of Class.forName(String).
TypeCreation	A stack manipulation for creating an undefined type on which a constructor is to be called.
TypeDefinition	Implementations define a type, either as a TypeDescription or as a TypeDescription.Generic.
TypeDefinition.Sort	Represents a TypeDescription.Generic's form.
TypeDefinition.SuperClassIterator	An iterator that iterates over a type's class hierarchy.
TypeDescription	Implementations of this interface represent a Java type, i.e.
TypeDescription.AbstractBase	An abstract base implementation of a type description.
TypeDescription.AbstractBase.OfSimpleType	An adapter implementation of a TypeDescription that describes any type that is not an array or a primitive type.
TypeDescription.AbstractBase.OfSimpleType.WithDelegation	An implementation of a type description that delegates all properties but the type's name to a delegate.
TypeDescription.ArrayProjection	A projection for an array type based on an existing TypeDescription.
TypeDescription.ForLoadedType	A type description implementation that represents a loaded type.
TypeDescription.ForLoadedType.ClassDescriptionTypeList	A list of type descriptions represented by class descriptions.
TypeDescription.ForLoadedType.ClassDescriptionTypeList.InternalNameLazyType	A lazy representation of an internal name for a given class loader.
TypeDescription.ForLoadedType.Dispatcher	A dispatcher for using methods of Class that are not declared for Java 6.
TypeDescription.ForLoadedType.Dispatcher.CreationAction	An action to resolve the dispatcher for invoking methods of Class reflectively.
TypeDescription.ForLoadedType.Dispatcher.ForJava11CapableVm	A dispatcher for a Java 11-capable VM.
TypeDescription.ForLoadedType.Dispatcher.ForJava16CapableVm	A dispatcher for a Java 16-capable VM.
TypeDescription.ForLoadedType.Dispatcher.ForLegacyVm	A dispatcher for a legacy VM.
TypeDescription.ForPackageDescription	A type representation of a package description.
TypeDescription.Generic	Represents a generic type of the Java programming language.
TypeDescription.Generic.AbstractBase	An abstract base implementation of a generic type description.
TypeDescription.Generic.AnnotationReader	An annotation reader is responsible for lazily evaluating type annotations if this language feature is available on the current JVM.
TypeDescription.Generic.AnnotationReader.Delegator	A delegating annotation reader that delegates all invocations to an annotation reader that wraps the previous one.
TypeDescription.Generic.AnnotationReader.Delegator.Chained	A chained delegator that bases its result on an underlying annotation reader.
TypeDescription.Generic.AnnotationReader.Delegator.ForRecordComponent	An annotation reader for a java.lang.reflect.RecordComponent.
TypeDescription.Generic.AnnotationReader.Dispatcher	A dispatcher that represents the type annotation API via reflective calls if the language feature is available on the current JVM.
TypeDescription.Generic.AnnotationReader.Dispatcher.CreationAction	A creation action for a dispatcher.
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm	A dispatcher for a modern JVM that supports type annotations.
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.AnnotatedTypeVariableType	A delegating annotation reader for an annotated type variable.
TypeDescription.Generic.AnnotationReader.Dispatcher.ForJava8CapableVm.Resolved	A delegator for an existing java.lang.reflect.AnnotatedElement.
TypeDescription.Generic.AnnotationReader.Dispatcher.ForLegacyVm	A dispatcher for TypeDescription.Generic.AnnotationReaders on a legacy VM that does not support type annotations.
TypeDescription.Generic.AnnotationReader.ForComponentType	A chained annotation reader for reading a component type.
TypeDescription.Generic.AnnotationReader.ForOwnerType	A chained annotation reader for reading an owner type.
TypeDescription.Generic.AnnotationReader.ForTypeArgument	A chained annotation reader for reading a parameterized type's type argument.
TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType	A chained annotation reader for reading a type variable's type argument.
TypeDescription.Generic.AnnotationReader.ForTypeVariableBoundType.OfFormalTypeVariable	A chained annotation reader for reading a formal type variable's type argument.
TypeDescription.Generic.AnnotationReader.ForWildcardLowerBoundType	A chained annotation reader for reading a wildcard type's lower bound type.
TypeDescription.Generic.AnnotationReader.ForWildcardUpperBoundType	A chained annotation reader for reading a wildcard type's upper bound type.
TypeDescription.Generic.AnnotationReader.NoOp	A non-operational annotation reader.
TypeDescription.Generic.Builder	A builder for creating describing a generic type as a TypeDescription.Generic.
TypeDescription.Generic.Builder.OfGenericArrayType	A generic type builder building a generic array type.
TypeDescription.Generic.Builder.OfNonGenericType	A generic type builder for building a non-generic type.
TypeDescription.Generic.Builder.OfParameterizedType	A generic type builder for building a parameterized type.
TypeDescription.Generic.Builder.OfTypeVariable	A generic type builder building a symbolic type variable.
TypeDescription.Generic.LazyProjection	A lazy projection of a generic type.
TypeDescription.Generic.LazyProjection.ForLoadedFieldType	A lazy projection of a field's type.
TypeDescription.Generic.LazyProjection.ForLoadedReturnType	A lazy projection of a method's generic return type.
TypeDescription.Generic.LazyProjection.ForLoadedSuperClass	A lazy projection of a generic super type.
TypeDescription.Generic.LazyProjection.OfConstructorParameter	A lazy projection of the parameter type of a Constructor.
TypeDescription.Generic.LazyProjection.OfMethodParameter	A lazy projection of the parameter type of a Method.
TypeDescription.Generic.LazyProjection.OfRecordComponent	A lazy projection of a java.lang.reflect.RecordComponent's type.
TypeDescription.Generic.LazyProjection.WithEagerNavigation	A lazy projection of a type that resolves super class and interface types eagerly.
TypeDescription.Generic.LazyProjection.WithEagerNavigation.OfAnnotatedElement	A description of an annotated lazy type with eager navigation.
TypeDescription.Generic.LazyProjection.WithLazyNavigation	A lazy projection of a type with a lazy resolution of super class and interface types.
TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazyInterfaceList	A lazy representation of a lazy projection's interfaces.
TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazyInterfaceType	A lazy interface type description for a lazy projection.
TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazySuperClass	A lazy super class description for a lazy projection.
TypeDescription.Generic.LazyProjection.WithLazyNavigation.OfAnnotatedElement	A description of an annotated lazy type with lazy navigation.
TypeDescription.Generic.LazyProjection.WithResolvedErasure	A lazy projection that applies a visitor only when resolving the generic type but not when reading the erasure.
TypeDescription.Generic.OfGenericArray	A base implementation of a generic type description that represents a potentially generic array.
TypeDescription.Generic.OfGenericArray.ForLoadedType	A description of a loaded generic array type.
TypeDescription.Generic.OfGenericArray.Latent	A latent implementation of a generic array type.
TypeDescription.Generic.OfNonGenericType	A raw type representation of a non-generic type.
TypeDescription.Generic.OfNonGenericType.ForErasure	A type description for a type erasure.
TypeDescription.Generic.OfNonGenericType.ForLoadedType	Represents a non-generic type for a loaded Class.
TypeDescription.Generic.OfNonGenericType.ForReifiedErasure	A representation of a raw type that preserves its generic super types' generic information with a minimum but erases all of their members' types.
TypeDescription.Generic.OfNonGenericType.Latent	A latent description of a non-generic type.
TypeDescription.Generic.OfParameterizedType	A base implementation of a generic type description that represents a parameterized type.
TypeDescription.Generic.OfParameterizedType.ForGenerifiedErasure	Represents an erasure as a generic type where all type variables are representing their own arguments.
TypeDescription.Generic.OfParameterizedType.ForLoadedType	Description of a loaded parameterized type.
TypeDescription.Generic.OfParameterizedType.ForLoadedType.ParameterArgumentTypeList	A type list that represents a loaded parameterized type's parameter types.
TypeDescription.Generic.OfParameterizedType.ForReifiedType	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.
TypeDescription.Generic.OfParameterizedType.Latent	A latent description of a parameterized type.
TypeDescription.Generic.OfParameterizedType.RenderingDelegate	A rendering delegate for resolving a parameterized type's Object.toString() representation.
TypeDescription.Generic.OfTypeVariable	A base implementation of a generic type description that represents a type variable.
TypeDescription.Generic.OfTypeVariable.ForLoadedType	Description of a loaded type variable.
TypeDescription.Generic.OfTypeVariable.ForLoadedType.TypeVariableBoundList	A list of type variable bounds for a loaded TypeVariable that resolves annotations..
TypeDescription.Generic.OfTypeVariable.Symbolic	Implementation of a symbolic type variable.
TypeDescription.Generic.OfTypeVariable.WithAnnotationOverlay	A type variable with explicit annotations that replace the annotations that are declared by the provided type variable.
TypeDescription.Generic.OfWildcardType	A base implementation of a generic type description that represents a wildcard type.
TypeDescription.Generic.OfWildcardType.ForLoadedType	Description of a loaded wildcard.
TypeDescription.Generic.OfWildcardType.ForLoadedType.WildcardLowerBoundTypeList	A type list representing an upper-bound type variable's bound types.
TypeDescription.Generic.OfWildcardType.ForLoadedType.WildcardUpperBoundTypeList	A type list representing an upper-bound type variable's bound types.
TypeDescription.Generic.OfWildcardType.Latent	A latent description of a wildcard type.
TypeDescription.Generic.Visitor<T>	A visitor that can be applied to a TypeDescription.Generic for differentiating on the sort of the visited type.
TypeDescription.Generic.Visitor.AnnotationStripper	A visitor that strips all type annotations of all types.
TypeDescription.Generic.Visitor.AnnotationStripper.NonAnnotatedTypeVariable	Representation of a type variable without annotations.
TypeDescription.Generic.Visitor.Assigner	A visitor that determines the direct assignability of a type to another generic type.
TypeDescription.Generic.Visitor.Assigner.Dispatcher	A dispatcher that allows to check if the visited generic type is assignable to the supplied type.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.AbstractBase	An abstract base implementation of a dispatcher that forwards the decision to a visitor implementation.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForGenericArray	A dispatcher for checking the assignability of a generic array type.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForNonGenericType	A dispatcher for checking the assignability of a non-generic type.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType	A dispatcher for checking the assignability of a parameterized type.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner	An assigner for a parameter of a parameterized type.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.ContravariantBinding	A dispatcher for an contravariant parameter of a parameterized type, i.e.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.CovariantBinding	A dispatcher for an covariant parameter of a parameterized type, i.e.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForParameterizedType.ParameterAssigner.InvariantBinding	A dispatcher for an invariant parameter of a parameterized type, i.e.
TypeDescription.Generic.Visitor.Assigner.Dispatcher.ForTypeVariable	A dispatcher for checking the assignability of a type variable.
TypeDescription.Generic.Visitor.ForRawType	A visitor that transforms any type into a raw type if declaring type is generified.
TypeDescription.Generic.Visitor.ForSignatureVisitor	Visits a generic type and appends the discovered type to the supplied signature visitor.
TypeDescription.Generic.Visitor.ForSignatureVisitor.OfTypeArgument	Visits a parameter while visiting a generic type for delegating discoveries to a signature visitor.
TypeDescription.Generic.Visitor.NoOp	A non-operational generic type visitor.
TypeDescription.Generic.Visitor.Reducing	A visitor that reduces a detached generic type to its erasure.
TypeDescription.Generic.Visitor.Reifying	A visitor that reifies type descriptions if they represent raw types.
TypeDescription.Generic.Visitor.Substitutor	An abstract implementation of a visitor that substitutes generic types by replacing (nested) type variables and/or non-generic component types.
TypeDescription.Generic.Visitor.Substitutor.ForAttachment	A substitutor that attaches type variables to a type variable source and replaces representations of TargetType with a given declaring type.
TypeDescription.Generic.Visitor.Substitutor.ForDetachment	A visitor for detaching a type from its declaration context by detaching type variables.
TypeDescription.Generic.Visitor.Substitutor.ForTokenNormalization	A substitutor that normalizes a token to represent all TargetType by a given type and that symbolizes all type variables.
TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding	A visitor for binding type variables to their values.
TypeDescription.Generic.Visitor.Substitutor.WithoutTypeSubstitution	A TypeDescription.Generic.Visitor.Substitutor that only substitutes type variables but fully preserves non-generic type definitions.
TypeDescription.Generic.Visitor.TypeErasing	A visitor that returns the erasure of any visited type.
TypeDescription.Generic.Visitor.Validator	A validator for Java types that are defined for a specified type use within a Java class file.
TypeDescription.Generic.Visitor.Validator.ForTypeAnnotations	A type validator for checking type annotations.
TypeDescription.Latent	A latent type description for a type without methods or fields.
TypeDescription.SuperTypeLoading	A delegating type description that always attempts to load the super types of a delegate type.
TypeDescription.SuperTypeLoading.ClassLoadingDelegate	A class loading delegate is responsible for resolving a type given a class loader and a type name.
TypeDescription.SuperTypeLoading.ClassLoadingDelegate.Simple	A simple class loading delegate that simply loads a type.
TypeDescription.SuperTypeLoading.ClassLoadingTypeList	A type list that attempts loading any type.
TypeDescription.SuperTypeLoading.ClassLoadingTypeProjection	A type projection that attempts to load any super type of the delegate type.
TypeInitializer	A type initializer is responsible for defining a type's static initialization block.
TypeInitializer.Drain	A drain for writing a type initializer.
TypeInitializer.Drain.Default	A default implementation of a type initializer drain that creates a initializer method.
TypeInitializer.None	Canonical implementation of a non-defined type initializer.
TypeInitializer.Simple	A simple, defined type initializer that executes a given ByteCodeAppender.
TypeList	Implementations represent a list of type descriptions.
TypeList.AbstractBase	An abstract base implementation of a type list.
TypeList.Empty	An implementation of an empty type list.
TypeList.Explicit	A wrapper implementation of an explicit list of types.
TypeList.ForLoadedTypes	Implementation of a type list for an array of loaded types.
TypeList.Generic	A list containing descriptions of generic types.
TypeList.Generic.AbstractBase	An abstract base implementation of a generic type list.
TypeList.Generic.Empty	An empty list of generic types.
TypeList.Generic.Explicit	An explicit list of generic types.
TypeList.Generic.ForDetachedTypes	A list of detached types that are attached on reception.
TypeList.Generic.ForDetachedTypes.OfTypeVariables	A list of attached type variables represented by a list of type variable tokens.
TypeList.Generic.ForDetachedTypes.OfTypeVariables.AttachedTypeVariable	A wrapper for representing a type variable in its attached state.
TypeList.Generic.ForDetachedTypes.WithResolvedErasure	A list of detached types that are attached on reception but not when computing an erasure.
TypeList.Generic.ForLoadedTypes	A list of loaded generic types.
TypeList.Generic.ForLoadedTypes.OfTypeVariables	A type list that represents loaded type variables.
TypeList.Generic.OfConstructorExceptionTypes	A lazy projection of a constructor's exception types.
TypeList.Generic.OfConstructorExceptionTypes.TypeProjection	A projection of a specific exception type.
TypeList.Generic.OfLoadedInterfaceTypes	A lazy projection of a type's generic interface types.
TypeList.Generic.OfLoadedInterfaceTypes.TypeProjection	A type projection of an interface type.
TypeList.Generic.OfMethodExceptionTypes	A lazy projection of a method's exception types.
TypeList.Generic.OfMethodExceptionTypes.TypeProjection	A projection of a specific exception type.
TypeManifestation	Describes a type's manifestation, i.e.
TypePool	A type pool allows the retrieval of TypeDescription by its name.
TypePool.AbstractBase	A base implementation of a TypePool that is managing a cache provider and that handles the description of array and primitive types.
TypePool.AbstractBase.ArrayTypeResolution	A resolution for a type that, if resolved, represents an array type.
TypePool.AbstractBase.ComponentTypeReference	A lazy representation of the component type of an array.
TypePool.AbstractBase.Hierarchical	Implements a hierarchical view of type pools, similarly to class loader hierarchies.
TypePool.CacheProvider	A cache provider for a TypePool.
TypePool.CacheProvider.Discriminating	A discriminating cache provider that delegates a type name to one of two caches.
TypePool.CacheProvider.NoOp	A non-operational cache that does not store any type descriptions.
TypePool.CacheProvider.Simple	A simple, thread-safe type cache based on a ConcurrentHashMap.
TypePool.ClassLoading	A type pool that attempts to load a class.
TypePool.Default	A default implementation of a TypePool that models binary data in the Java byte code format into a TypeDescription.
TypePool.Default.AnnotationRegistrant	An annotation registrant implements a visitor pattern for reading an unknown amount of values of annotations.
TypePool.Default.AnnotationRegistrant.AbstractBase	An abstract base implementation of an annotation registrant.
TypePool.Default.AnnotationRegistrant.AbstractBase.ForTypeVariable	A base implementation for a collector for a type variable.
TypePool.Default.AnnotationRegistrant.AbstractBase.ForTypeVariable.WithIndex	A base implementation for a collector for a type variable with an index.
TypePool.Default.AnnotationRegistrant.AbstractBase.ForTypeVariable.WithIndex.DoubleIndexed	A base implementation for a collector for a type variable with two indices.
TypePool.Default.AnnotationRegistrant.ForByteCodeElement	An annotation collector for a byte code element.
TypePool.Default.AnnotationRegistrant.ForByteCodeElement.WithIndex	An annotation collector for a byte code element with an index.
TypePool.Default.AnnotationRegistrant.ForTypeVariable	An annotation collector for a type variable.
TypePool.Default.AnnotationRegistrant.ForTypeVariable.WithIndex	An annotation collector for a type variable with an index.
TypePool.Default.AnnotationRegistrant.ForTypeVariable.WithIndex.DoubleIndexed	An annotation collector for a type variable with two indices.
TypePool.Default.ComponentTypeLocator	A component type locator allows for the lazy location of an array's component type.
TypePool.Default.ComponentTypeLocator.ForAnnotationProperty	A component type locator that lazily analyses an annotation for resolving an annotation property's array value's component type.
TypePool.Default.ComponentTypeLocator.ForArrayType	A component type locator that locates an array type by a method's return value from its method descriptor.
TypePool.Default.ComponentTypeLocator.Illegal	A component type locator which cannot legally resolve an array's component type.
TypePool.Default.GenericTypeExtractor	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.
TypePool.Default.GenericTypeExtractor.ForSignature.OfField	A parser for a generic field signature.
TypePool.Default.GenericTypeExtractor.ForSignature.OfMethod	A parser for a generic method signature.
TypePool.Default.GenericTypeExtractor.ForSignature.OfRecordComponent	A parser for a generic field signature.
TypePool.Default.GenericTypeExtractor.ForSignature.OfType	A parser for a generic type signature.
TypePool.Default.GenericTypeExtractor.IncompleteToken	An incomplete TypePool.Default.LazyTypeDescription.GenericTypeToken.
TypePool.Default.GenericTypeExtractor.IncompleteToken.AbstractBase	An abstract base implementation of an incomplete token.
TypePool.Default.GenericTypeExtractor.IncompleteToken.ForInnerClass	An incomplete generic type token representing a type with an outer type.
TypePool.Default.GenericTypeExtractor.IncompleteToken.ForTopLevelType	An incomplete token representing a generic type without an outer type.
TypePool.Default.GenericTypeRegistrant	A type registrant allows to register a generic type token.
TypePool.Default.GenericTypeRegistrant.RejectingSignatureVisitor	A signature visitor that rejects any discovered generic type.
TypePool.Default.LazyTypeDescription	A type description that looks up any referenced ByteCodeElement or AnnotationDescription by querying a type pool at lookup time.
TypePool.Default.LazyTypeDescription.AnnotationToken	A token for representing collected data on an annotation.
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution	A resolution for an annotation tokens.
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Illegal	An illegal resolution.
TypePool.Default.LazyTypeDescription.AnnotationToken.Resolution.Simple	A simple resolved annotation.
TypePool.Default.LazyTypeDescription.FieldToken	A token for representing collected data on a field.
TypePool.Default.LazyTypeDescription.GenericTypeToken	A token that represents a generic Java type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray	A generic type token that represents a generic array.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray.LazyGenericArray	A generic type representation of a generic array.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard	A generic type token for a wildcard that is bound below.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard.LazyLowerBoundWildcard	A generic type representation of a lower bound wildcard.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType	A generic type token that represents a parameterized type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.LazyParameterizedType	A generic type description that represents a parameterized type without an enclosing generic owner type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested	A generic type token to describe a parameterized type description with a generic owner type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested.LazyParameterizedType	A lazy description of a parameterized type with an owner type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType	A generic type token that represents a primitive type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType.LazyPrimitiveType	A representation of a lazy primitive type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForRawType	A generic type token that represents a non-generic type.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable	A generic type token that represents a type variable.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.AnnotatedTypeVariable	An annotated representation of a formal type variable.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal	A generic type token that represent a formal type variable, i.e.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal.LazyTypeVariable	A type description that represents a type variable with bounds that are resolved lazily.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal.LazyTypeVariable.LazyBoundTokenList	A list representing a formal type variable's bounds.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.UnresolvedTypeVariable	Represents a type variable that a type references but that does not exist.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUnboundWildcard	A generic type token that represents an unbound wildcard.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUnboundWildcard.LazyUnboundWildcard	A generic type representation of a generic unbound wildcard.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard	A generic type token for a wildcard that is bound above.
TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard.LazyUpperBoundWildcard	A generic type representation of a tokenized wildcard with an upper bound.
TypePool.Default.LazyTypeDescription.GenericTypeToken.LazyTokenList	A lazy list of type tokens.
TypePool.Default.LazyTypeDescription.GenericTypeToken.LazyTokenList.ForWildcardBound	A generic type description representing a tokenized wildcard bound.
TypePool.Default.LazyTypeDescription.GenericTypeToken.OfFormalTypeVariable	Represents a generic type token for a formal type variable.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution	A resolution of a type's, method's or field's generic types.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField	A resolution of the generic type of a FieldDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField.Tokenized	An implementation of a tokenized resolution of the generic type of a FieldDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod	A resolution of the generic types of a MethodDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized	An implementation of a tokenized resolution of generic types of a MethodDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForRecordComponent	A resolution of the generic type of a RecordComponentDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForRecordComponent.Tokenized	An implementation of a tokenized resolution of the generic type of a RecordComponentDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType	A resolution of the generic types of a TypeDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized	An implementation of a tokenized resolution of generic types of a TypeDescription.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed	A resolution of a type's, method's or field's generic types if its generic signature is malformed.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw	A resolution of a type's, method's or field's generic types if all of the represented element's are raw.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType	Represents a non-generic type that defines type annotations.
TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType.LazyRawAnnotatedTypeList	A generic type list representing raw types.
TypePool.Default.LazyTypeDescription.LazyAnnotationDescription	A lazy description of an annotation that looks up types from a type pool when required.
TypePool.Default.LazyTypeDescription.LazyAnnotationDescription.Loadable<S extends java.lang.annotation.Annotation>	A loadable version of a lazy annotation description.
TypePool.Default.LazyTypeDescription.LazyAnnotationValue<U,V>	A proxy for a lazy annotation value.
TypePool.Default.LazyTypeDescription.LazyAnnotationValue.ForAnnotationValue	A lazy annotation value description for an annotation value.
TypePool.Default.LazyTypeDescription.LazyAnnotationValue.ForArray	A lazy projection of an annotation value that contains an array of values.
TypePool.Default.LazyTypeDescription.LazyAnnotationValue.ForEnumerationValue	A lazy annotation value description for an enumeration value.
TypePool.Default.LazyTypeDescription.LazyAnnotationValue.ForTypeValue	A lazy annotation value description for a type value.
TypePool.Default.LazyTypeDescription.LazyNestMemberList	A lazy list that represents all nest members of the represented type.
TypePool.Default.LazyTypeDescription.LazyPackageDescription	An implementation of a PackageDescription that only loads its annotations on requirement.
TypePool.Default.LazyTypeDescription.LazyTypeList	A list that is constructing TypePool.Default.LazyTypeDescriptions.
TypePool.Default.LazyTypeDescription.MethodToken	A token for representing collected data on a method.
TypePool.Default.LazyTypeDescription.MethodToken.ParameterToken	A token representing a method's parameter.
TypePool.Default.LazyTypeDescription.RecordComponentToken	A token representing a record component.
TypePool.Default.LazyTypeDescription.TokenizedGenericType	A representation of a generic type that is described by a TypePool.Default.LazyTypeDescription.GenericTypeToken.
TypePool.Default.LazyTypeDescription.TokenizedGenericType.Malformed	A lazy description of a non-well-defined described generic type.
TypePool.Default.LazyTypeDescription.TokenizedGenericType.Malformed.TokenList	A tokenized list of non-well-defined generic types.
TypePool.Default.LazyTypeDescription.TokenizedGenericType.TokenList	A tokenized list of generic types.
TypePool.Default.LazyTypeDescription.TokenizedGenericType.TypeVariableList	A list of tokenized type variables.
TypePool.Default.LazyTypeDescription.TypeContainment	A declaration context encapsulates information about whether a type was declared within another type or within a method of another type.
TypePool.Default.LazyTypeDescription.TypeContainment.SelfContained	Describes a type that is not contained within another type, a method or a constructor.
TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod	Describes a type that is contained within a method or constructor.
TypePool.Default.LazyTypeDescription.TypeContainment.WithinType	Describes a type that is contained within another type.
TypePool.Default.ParameterBag	A bag for collecting parameter meta information that is stored as debug information for implemented methods.
TypePool.Default.ReaderMode	Determines the granularity of the class file parsing that is conducted by a TypePool.Default.
TypePool.Default.WithLazyResolution	A variant of TypePool.Default that resolves type descriptions lazily.
TypePool.Empty	An empty type pool that cannot describe any type.
TypePool.Explicit	A type pool that supplies explicitly known type descriptions.
TypePool.LazyFacade	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.
TypePool.LazyFacade.LazyResolution	The lazy resolution for a lazy facade for a type pool.
TypePool.LazyFacade.LazyTypeDescription	A description of a type that delegates to another type pool once a property that is not the name is resolved.
TypePool.Resolution	A resolution of a TypePool which was queried for a description.
TypePool.Resolution.Illegal	A canonical representation of a non-successful resolution of a TypePool.
TypePool.Resolution.Simple	A simple resolution that represents a given TypeDescription.
TypeProxy	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.
TypeProxy.AbstractMethodErrorThrow	A stack manipulation that throws an abstract method error in case that a given super method cannot be invoked.
TypeProxy.ForDefaultMethod	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.
TypeProxy.ForSuperMethodByConstructor	Loads a type proxy onto the operand stack which is created by calling one of its constructors.
TypeProxy.ForSuperMethodByReflectionFactory	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.
TypeProxy.InvocationFactory	An invocation factory is responsible for creating a special method invocation for any method that is to be invoked.
TypeProxy.InvocationFactory.Default	Default implementations of the TypeProxy.InvocationFactory.
TypeProxy.SilentConstruction	An implementation of a silent construction of a given type by using the non-standardized ReflectionFactory.
TypeProxy.SilentConstruction.Appender	The appender for implementing a TypeProxy.SilentConstruction.
TypeReferenceAdjustment	Adds an attribute value for all inner classes that are referenced by the instrumented type.
TypeReferenceAdjustment.TypeReferenceClassVisitor	A class visitor that collects all type references and all inner class references.
TypeResolutionStrategy	A type resolution strategy is responsible for loading a class and for initializing its LoadedTypeInitializers.
TypeResolutionStrategy.Active	A type resolution strategy that applies all LoadedTypeInitializer as a part of class loading using reflection.
TypeResolutionStrategy.Active.Resolved	A resolved version of an active type resolution strategy.
TypeResolutionStrategy.Disabled	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.
TypeResolutionStrategy.Lazy	A type resolution strategy that does not apply any LoadedTypeInitializers but only loads all types.
TypeResolutionStrategy.Passive	A type resolution strategy that applies all LoadedTypeInitializer after class loading using reflection.
TypeResolutionStrategy.Resolved	A resolved TypeResolutionStrategy.
TypeSortMatcher<T extends TypeDefinition>	An element matcher that validates that a given generic type description represents a type of a given name.
TypeValidation	If type validation is enabled, Byte Buddy performs several checks to ensure that a generated class file is specified in a valid manner.
TypeVariableSource	A type variable source represents a code element that can declare type variables.
TypeVariableSource.AbstractBase	An abstract base implementation of a type variable source.
TypeVariableSource.Visitor<T>	A visitor that can be applied to a type variable source.
TypeVariableSource.Visitor.NoOp	A none-operational implementation of a type variable visitor that simply returns the visited source.
TypeVariableToken	A tokenized representation of a type variable.
TypeWriter<T>	A type writer is a utility for writing an actual class file using the ASM library.
TypeWriter.Default<S>	A default implementation of a TypeWriter.
TypeWriter.Default.ClassDumpAction	An action to write a class file to the dumping location.
TypeWriter.Default.ClassDumpAction.Dispatcher	A dispatcher for dumping class files to the file system.
TypeWriter.Default.ClassDumpAction.Dispatcher.Disabled	A disabled dispatcher that does not dump any class files.
TypeWriter.Default.ClassDumpAction.Dispatcher.Enabled	An enabled dispatcher that dumps class files to a given folder.
TypeWriter.Default.ForCreation<U>	A type writer that creates a class file that is not based upon another, existing class.
TypeWriter.Default.ForInlining<U>	A type writer that inlines the created type into an existing class file.
TypeWriter.Default.ForInlining.ContextRegistry	A context registry allows to extract auxiliary types from a lazily created implementation context.
TypeWriter.Default.ForInlining.WithDecorationOnly<V>	A default type writer that only applies a type decoration.
TypeWriter.Default.ForInlining.WithDecorationOnly.LazyFieldList	A field list that only reads fields lazy to avoid an eager lookup since fields are often not required.
TypeWriter.Default.ForInlining.WithFullProcessing<V>	A default type writer that reprocesses a type completely.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler	An initialization handler is responsible for handling the creation of the type initializer.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending	An initialization handler that appends code to a previously visited type initializer.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.FrameWriter	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.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.FrameWriter.Expanding	A frame writer that creates an expanded frame.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.FrameWriter.NoOp	A non-operational frame writer.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.WithDrain	An initialization handler that appends code to a previously visited type initializer with allowing active TypeInitializer registrations.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.WithDrain.WithActiveRecord	A code appending initialization handler with a drain that applies an explicit record.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.WithDrain.WithoutActiveRecord	A code appending initialization handler with a drain that does not apply an explicit record.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.WithoutDrain	An initialization handler that appends code to a previously visited type initializer without allowing active TypeInitializer registrations.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.WithoutDrain.WithActiveRecord	An initialization handler that appends code to a previously visited type initializer without allowing active TypeInitializer registrations and with an active record.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Appending.WithoutDrain.WithoutActiveRecord	An initialization handler that appends code to a previously visited type initializer without allowing active TypeInitializer registrations and without an active record.
TypeWriter.Default.ForInlining.WithFullProcessing.InitializationHandler.Creating	An initialization handler that creates a new type initializer.
TypeWriter.Default.ForInlining.WithFullProcessing.OpenedClassRemapper	A ClassRemapper that uses the Byte Buddy-defined API version.
TypeWriter.Default.ValidatingClassVisitor	A class validator that validates that a class only defines members that are appropriate for the sort of the generated class.
TypeWriter.Default.ValidatingClassVisitor.Constraint	A constraint for members that are legal for a given type.
TypeWriter.Default.ValidatingClassVisitor.Constraint.Compound	A constraint implementation that summarizes several constraints.
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForAnnotation	Represents the constraint of an annotation type.
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForClass	Represents the constraint of a class type.
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForClassFileVersion	Represents the constraint implied by a class file version.
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForInterface	Represents the constraint of an interface type.
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForPackageType	Represents the constraint of a package type.
TypeWriter.Default.ValidatingClassVisitor.Constraint.ForRecord	Represents the constraint of a record type.
TypeWriter.FieldPool	An field pool that allows a lookup for how to implement a field.
TypeWriter.FieldPool.Disabled	A field pool that does not allow any look ups.
TypeWriter.FieldPool.Record	An entry of a field pool that describes how a field is implemented.
TypeWriter.FieldPool.Record.ForExplicitField	A record for a rich field with attributes and a potential default value.
TypeWriter.FieldPool.Record.ForImplicitField	A record for a simple field without a default value where all of the field's declared annotations are appended.
TypeWriter.MethodPool	An method pool that allows a lookup for how to implement a method.
TypeWriter.MethodPool.Record	An entry of a method pool that describes how a method is implemented.
TypeWriter.MethodPool.Record.AccessBridgeWrapper	A wrapper that appends accessor bridges for a method's implementation.
TypeWriter.MethodPool.Record.AccessBridgeWrapper.AccessorBridge	A method representing an accessor bridge method.
TypeWriter.MethodPool.Record.AccessBridgeWrapper.BridgeTarget	A method representing a bridge's target method in its defined shape.
TypeWriter.MethodPool.Record.ForDefinedMethod	A base implementation of an abstract entry that defines a method.
TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge	A record for a visibility bridge.
TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge.VisibilityBridge	A method describing a visibility bridge.
TypeWriter.MethodPool.Record.ForDefinedMethod.WithAnnotationDefaultValue	Describes an entry that defines a method with a default annotation value.
TypeWriter.MethodPool.Record.ForDefinedMethod.WithBody	Describes an entry that defines a method as byte code.
TypeWriter.MethodPool.Record.ForDefinedMethod.WithoutBody	Describes an entry that defines a method but without byte code and without an annotation value.
TypeWriter.MethodPool.Record.ForNonImplementedMethod	A canonical implementation of a method that is not declared but inherited by the instrumented type.
TypeWriter.MethodPool.Record.Sort	The sort of an entry.
TypeWriter.RecordComponentPool	An record component pool that allows a lookup for how to implement a record component.
TypeWriter.RecordComponentPool.Disabled	A record component pool that does not allow any look ups.
TypeWriter.RecordComponentPool.Record	An entry of a record component pool that describes how a record component is implemented.
TypeWriter.RecordComponentPool.Record.ForExplicitRecordComponent	A record for a rich record component with attributes.
TypeWriter.RecordComponentPool.Record.ForImplicitRecordComponent	A record for a simple field without a default value where all of the record component's declared annotations are appended.
VirtualMachine	An implementation for attachment on a virtual machine.
VirtualMachine.AbstractBase	An abstract base implementation for a virtual machine.
VirtualMachine.ForHotSpot	A virtual machine attachment implementation for a HotSpot VM or any compatible JVM.
VirtualMachine.ForHotSpot.Connection	Represents a connection to a virtual machine.
VirtualMachine.ForHotSpot.Connection.Factory	A factory for creating connections to virtual machines.
VirtualMachine.ForHotSpot.Connection.Factory.ForSocketFile	A factory for attaching via a socket file.
VirtualMachine.ForHotSpot.Connection.OnPersistentByteChannel<T>	A connection that is represented by a byte channel that is persistent during communication.
VirtualMachine.ForHotSpot.Connection.Response	A response to an execution command to a VM.
VirtualMachine.ForOpenJ9	A virtual machine attachment implementation for OpenJ9 or any compatible JVM.
VirtualMachine.ForOpenJ9.Dispatcher	A dispatcher for native operations being used for communication with an OpenJ9 virtual machine.
VirtualMachine.Resolver	A resolver for the current VM's virtual machine attachment emulation.
Visibility	Describes a type's, field's or a method's visibility.
VisibilityBridgeStrategy	Implements a strategy for deciding if a visibility bridge should be generated.
VisibilityBridgeStrategy.Default	Default implementations of visibility bridge strategies.
VisibilityMatcher<T extends ByteCodeElement>	An element matcher that validates that a given byte code element is visible to a given type.
VoidAwareAssigner	This assigner is able to handle the void type.