@NeverNull.ByDefault

Package net.bytebuddy.asm

The ASM package contains classes that are meant for direct interaction with the ASM API.

See: Description

Interface Summary

Interface	Description
Advice.ArgumentHandler	An argument handler is responsible for resolving offsets of the local variable array in the context of the applied instrumentation.
Advice.ArgumentHandler.ForAdvice	An argument handler that is used for resolving an advice method.
Advice.ArgumentHandler.ForInstrumentedMethod	An argument handler that is used for resolving the instrumented method.
Advice.AssignReturned.ExceptionHandler.Factory	A factory for wrapping an assignment with an exception handler, if appropriate.
Advice.AssignReturned.Handler	A handler for an Advice.AssignReturned post processor to assign a value that was returned by advice to a value of the instrumented method.
Advice.AssignReturned.Handler.Factory<T extends Annotation>	A factory for resolving a handler for a given advice method.
Advice.Delegator	Materializes an advice invocation within a delegation.
Advice.Dispatcher	A dispatcher for implementing advice.
Advice.Dispatcher.Bound	A bound resolution of an advice method.
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.Relocation	A relocator is responsible for triggering a relocation if a relocation handler triggers a relocating condition.
Advice.Dispatcher.Resolved	Represents a 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.Unresolved	A dispatcher that is not yet resolved.
Advice.ExceptionHandler	An exception handler is responsible for providing byte code for handling an exception thrown from a suppressing advice method.
Advice.MethodSizeHandler	A handler for computing the instrumented method's size.
Advice.MethodSizeHandler.ForAdvice	A method size handler for an advice method.
Advice.MethodSizeHandler.ForInstrumentedMethod	A method size handler for the instrumented method.
Advice.OffsetMapping	Represents an offset mapping for an advice method to an alternative offset.
Advice.OffsetMapping.Factory<T extends Annotation>	Represents a factory for creating a Advice.OffsetMapping for a given parameter for a given annotation.
Advice.OffsetMapping.ForOrigin.Renderer	A renderer for an origin pattern element.
Advice.OffsetMapping.Target	A target offset of an offset mapping.
Advice.PostProcessor	A post processor for advice methods that is invoked after advice is executed.
Advice.PostProcessor.Factory	A factory for creating a Advice.PostProcessor.
Advice.StackMapFrameHandler	A handler for computing and translating stack map frames.
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.ForPostProcessor	A stack map frame handler that can be used within a post processor.
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.ForDeclaredFields.FieldVisitorWrapper	A field visitor wrapper that allows for wrapping a FieldVisitor defining a declared field.
AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper	A method visitor wrapper that allows for wrapping a MethodVisitor defining a declared method.
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.Factory	A factory for creating a replacement for an instrumented method.
MemberSubstitution.Substitution	A substitution replaces or enhances an interaction with a field or method within an instrumented method.
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.Factory	A factory for creating a substitution for an instrumented method.
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver	A method resolver for locating a field for a substitute.
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver	A method resolver for locating a method for a substitute.
MemberSubstitution.TypePoolResolver	A type pool resolver is responsible for resolving a TypePool for locating substituted members.

Class Summary

Class	Description
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.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.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.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.AssignReturned	A post processor that uses the return value of an advice method to define values for fields, arguments, the instrumented method's return value or the exception being thrown.
Advice.AssignReturned.DefaultValueSkip	A stack manipulation that applies a null-check on the returned value which indicates if an assignment should be skipped, if discovered.
Advice.AssignReturned.ExceptionHandler	An exception handler to handle exceptions during assignment.
Advice.AssignReturned.ExceptionHandler.Factory.Enabled	A factory that creates an exception handler for a given exception type.
Advice.AssignReturned.Factory	A factory to create a Advice.AssignReturned post processor.
Advice.AssignReturned.ForArray	A post processor implementation of Advice.AssignReturned that works on the value of an array.
Advice.AssignReturned.ForScalar	A post processor implementation of Advice.AssignReturned that uses the returned value as such.
Advice.AssignReturned.Handler.Factory.Simple<S extends Annotation>	A simple implementation of a Advice.AssignReturned.ToArguments.Handler.Factory that resolves a given list of Handlers.
Advice.AssignReturned.ToAllArguments.Handler	A handler for a Advice.AssignReturned.ToAllArguments annotation.
Advice.AssignReturned.ToArguments.Handler	A handler for a Advice.AssignReturned.ToArguments.ToArgument annotation.
Advice.AssignReturned.ToFields.Handler	A handler for a Advice.AssignReturned.ToFields.ToField annotation.
Advice.AssignReturned.ToReturned.Handler	A handler for a Advice.AssignReturned.ToReturned annotation.
Advice.AssignReturned.ToThis.Handler	A handler for the Advice.AssignReturned.ToThis annotation.
Advice.AssignReturned.ToThrown.Handler	A handler for a Advice.AssignReturned.ToThrown annotation.
Advice.Delegator.ForDynamicInvocation	Invokes an advice method using a dynamic method call.
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.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.ForType	A relocation handler that is triggered if the checked value is an instance of a given type.
Advice.Dispatcher.RelocationHandler.Relocation.ForLabel	A relocation that unconditionally jumps to a given label.
Advice.Dispatcher.Resolved.AbstractBase	An abstract base implementation of a Advice.OffsetMapping.ForArgument.Resolved dispatcher.
Advice.Dispatcher.SuppressionHandler.Suppressing	A suppression handler that suppresses a given throwable type.
Advice.Dispatcher.SuppressionHandler.Suppressing.Bound	An active, bound suppression handler.
Advice.ExceptionHandler.Simple	A simple exception handler that returns a fixed stack manipulation.
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.OffsetMapping.Factory.Illegal<T extends Annotation>	A factory for an annotation whose use is not permitted.
Advice.OffsetMapping.Factory.Simple<T extends 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.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 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.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 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.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.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.Renderer.ForConstantValue	A renderer for a constant value.
Advice.OffsetMapping.ForReturnValue	An offset mapping that provides access to the value that is returned by the instrumented method.
Advice.OffsetMapping.ForSerializedValue	An offset mapping that loads a serialized value.
Advice.OffsetMapping.ForSerializedValue.Factory<T extends 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 Annotation>	A factory that binds a stack manipulation.
Advice.OffsetMapping.ForStackManipulation.OfAnnotationProperty<T extends Annotation>	A factory for binding an annotation's property.
Advice.OffsetMapping.ForStackManipulation.OfDefaultValue<T extends Annotation>	A factory for binding the annotated parameter's default value.
Advice.OffsetMapping.ForStackManipulation.OfDynamicInvocation<T extends Annotation>	Uses dynamic method invocation for binding an annotated parameter to a value.
Advice.OffsetMapping.ForThisReference	An offset mapping that provides access to the this reference of the instrumented method.
Advice.OffsetMapping.ForThrowable	An offset mapping for accessing a Throwable of 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.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.ForField.WriteOnly	A write-only mapping for a field value, typically to be used for constructors prior to invoking the super-constructor.
Advice.OffsetMapping.Target.ForStackManipulation	A target for an offset mapping that represents a read-only stack manipulation.
Advice.OffsetMapping.Target.ForStackManipulation.Writable	A constant value that can be written to.
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.OnNonDefaultValue	A marker type to be used as an argument for Advice.OnMethodEnter.skipOn().
Advice.PostProcessor.Compound	A compound post processor.
Advice.PostProcessor.Factory.Compound	A compound factory for a post processor.
Advice.StackMapFrameHandler.Default	A default implementation of a stack map frame handler for an instrumented method.
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.WithArgumentCopy	A stack map frame handler that expects that an argument copy of the original method arguments was made.
Advice.StackMapFrameHandler.Default.WithPreservedArguments.WithoutArgumentCopy	A stack map frame handler that expects that the original argument frames remain preserved throughout the original invocation.
Advice.WithCustomMapping	A builder step for creating an Advice that uses custom mappings of annotations to constant pool values.
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.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.
ClassVisitorFactory<T>	A factory for wrapping a ClassVisitor in Byte Buddy's package namespace to a ClassVisitor in any other namespace.
ClassVisitorFactory.AttributeTranslator	A method to wrap an Attribute.
ClassVisitorFactory.ConstantArrayTranslator	A method to translate an array of constants from one namespace to another.
ClassVisitorFactory.ConstantDynamicTranslator	A method to translate a ConstantDynamic from one namespace to another.
ClassVisitorFactory.ConstantTranslator	A method to translate a constant value from one namespace to another.
ClassVisitorFactory.CreateClassVisitorFactory<S>	A factory for creating a wrapper for a ClassVisitor.
ClassVisitorFactory.FrameTranslator	A method to translate a stack map frame array from one namespace to another.
ClassVisitorFactory.HandleTranslator	A method to translate a Handle from one namespace to another.
ClassVisitorFactory.LabelArrayTranslator	A method to translate an array of Labels from one namespace to another.
ClassVisitorFactory.LabelTranslator	A method to translate a Label from one namespace to another.
ClassVisitorFactory.NullCheckedConstruction	An appender that performs a null-checked construction.
ClassVisitorFactory.TypePathTranslator	A method to translate a TypePath type from one namespace to another.
MemberAttributeExtension<T>	A visitor that adds attributes to a class member.
MemberAttributeExtension.ForField	A visitor that adds attributes to a field.
MemberAttributeExtension.ForMethod	A visitor that adds attributes to a method.
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.Binding.Resolved	A binding that was resolved for an actual substitution.
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.SubstitutingMethodVisitor	A method visitor that applies a substitution for matched methods.
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.Simple	A simple substitution step within a substitution chain.
MemberSubstitution.Substitution.ForFieldAccess	A substitution with a field access.
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.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.OfMatchedMethod	A factory for a substitution that locates a method on the receiver type using a matcher.
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.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.
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.
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).
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.

Enum Summary

Enum	Description
Advice.ArgumentHandler.Factory	A factory for creating an argument handler.
Advice.AssignReturned.DefaultValueSkip.Dispatcher	A dispatcher for skipping a default value.
Advice.AssignReturned.ExceptionHandler.Factory.NoOp	A non-operational factory that does not produce an exception handler.
Advice.AssignReturned.ToAllArguments.Handler.Factory	A factory to create a handler for a Advice.AssignReturned.ToAllArguments annotation.
Advice.AssignReturned.ToArguments.Handler.Factory	A factory to create a handler for a Advice.AssignReturned.ToArguments annotation.
Advice.AssignReturned.ToFields.Handler.Factory	A factory to create a handler for a Advice.AssignReturned.ToFields annotation.
Advice.AssignReturned.ToReturned.Handler.Factory	A factory to create a handler for a Advice.AssignReturned.ToReturned annotation.
Advice.AssignReturned.ToThis.Handler.Factory	A handler factory for the Advice.AssignReturned.ToThis annotation which assigns an advice method's return value to the this reference of a non-static method.
Advice.AssignReturned.ToThrown.Handler.Factory	A factory to create a handler for a Advice.AssignReturned.ToThrown annotation.
Advice.Delegator.ForStaticInvocation	Invokes an advice method using a static method call.
Advice.Dispatcher.Inactive	An implementation for inactive devise that does not write any byte code.
Advice.Dispatcher.RelocationHandler.Disabled	A disabled relocation handler that does never trigger a relocation.
Advice.Dispatcher.RelocationHandler.ForValue	A relocation handler that triggers a relocation for a default or non-default value.
Advice.Dispatcher.SuppressionHandler.NoOp	A non-operational suppression handler that does not suppress any method.
Advice.ExceptionHandler.Default	Default implementations for commonly used exception handlers.
Advice.MethodSizeHandler.NoOp	A non-operational method size handler.
Advice.OffsetMapping.Factory.AdviceType	Describes the type of advice being applied.
Advice.OffsetMapping.ForAllArguments.Factory	A factory for an offset mapping that maps all arguments values of the instrumented method.
Advice.OffsetMapping.ForArgument.Unresolved.Factory	A factory for a mapping of a parameter of the instrumented method.
Advice.OffsetMapping.ForField.Unresolved.Factory	A factory for a Advice.OffsetMapping.ForArgument.Unresolved offset mapping.
Advice.OffsetMapping.ForInstrumentedMethod	Maps a constant representing the instrumented method.
Advice.OffsetMapping.ForInstrumentedType	Maps the declaring type of the instrumented method.
Advice.OffsetMapping.ForOrigin.Factory	A factory for a method origin.
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.Factory	A factory for creating a Advice.OffsetMapping.ForReturnValue offset mapping.
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.Factory	A factory for creating a Advice.OffsetMapping.ForThisReference offset mapping.
Advice.OffsetMapping.ForThrowable.Factory	A factory for accessing an exception that was thrown by the instrumented method.
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.PostProcessor.NoOp	A non-operational advice post processor.
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.NoOp	A non-operational stack map frame handler.
AsmVisitorWrapper.NoOp	A class visitor wrapper that does not apply any changes.
MemberSubstitution.Replacement.Binding.Unresolved	An unresolved binding.
MemberSubstitution.Replacement.InvocationType	Describes a method invocation type.
MemberSubstitution.Replacement.NoOp	A non-operational replacement.
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.OfImplicitPool	Returns the implicit type pool.
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.

Annotation Types Summary

Annotation Type	Description
Advice.AllArguments	Assigns an array containing all arguments of the instrumented method to the annotated parameter.
Advice.Argument	Indicates that the annotated parameter should be mapped to the parameter with index Advice.Argument.value() of the instrumented method.
Advice.AssignReturned.AsScalar	Indicates that the advice method's return value is to be treated as a scalar value also if it is of an array type.
Advice.AssignReturned.ToAllArguments	Assigns the advice method's return value as an array to a number of arguments which are returned as an array where each element assigns a single value with the same index as the instrumented method's parameter.
Advice.AssignReturned.ToArguments	Assigns the advice method's return value to an argument of the instrumented method of the given index.
Advice.AssignReturned.ToArguments.ToArgument	Defines a particular assignment for a Advice.AssignReturned.ToArguments.
Advice.AssignReturned.ToFields	Assigns the advice method's return value to a given field.
Advice.AssignReturned.ToFields.ToField	Determines what fields are assigned when using a Advice.AssignReturned.ToFields annotation.
Advice.AssignReturned.ToReturned	Assigns the advice method's return value to the instrumented method's return value.
Advice.AssignReturned.ToThis	Assigns the advice method's return value to the this reference of the instrumented method.
Advice.AssignReturned.ToThrown	Assigns the advice method's return value to the instrumented method's return value.
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.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.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.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.Return	Indicates that the annotated parameter should be mapped to the return value of the instrumented method.
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.

Package net.bytebuddy.asm Description

The ASM package contains classes that are meant for direct interaction with the ASM API.