| Package | Description | 
|---|---|
| net.bytebuddy | 
 Byte Buddy is a library for creating Java classes at runtime of a Java program. 
 | 
| net.bytebuddy.agent.builder | 
 An agent builder is used to easily implement load-time class-transformations using a Java agent. 
 | 
| net.bytebuddy.asm | 
 The ASM package contains classes that are meant for direct interaction with the ASM API. 
 | 
| net.bytebuddy.build | 
 A package for types that allow for applying Byte Buddy transformation during a build process. 
 | 
| net.bytebuddy.dynamic | 
 This package contains classes and interfaces that are connected to writing the byte stream that represents a Java
 type that is dynamically created and for loading this type into a running JVM process. 
 | 
| net.bytebuddy.dynamic.scaffold | 
 This package contains helper types and implementations that are responsible for the actual writing of a byte array
 representing a Java class. 
 | 
| net.bytebuddy.dynamic.scaffold.inline | 
 All classes and types in this package are related to creating a  
DynamicType by
 enhancing a given type. | 
| net.bytebuddy.dynamic.scaffold.subclass | 
 All classes and types in this package are related to creating a  
DynamicType by
 creating a subclass of a given type. | 
| net.bytebuddy.implementation | 
 The implementation package contains any logic for intercepting method calls. 
 | 
| net.bytebuddy.implementation.auxiliary | 
 Auxiliary types describe helper types that aid as a supplementary to a given
  
InstrumentedType. | 
| net.bytebuddy.implementation.bind | 
 The types and classes of this package are responsible for binding a method call to calling another method. 
 | 
| net.bytebuddy.implementation.bind.annotation | 
 This package contains annotations, types and classes that are responsible for binding a method to calling another
 method by interpreting annotations that indicate how a method should be bound to another method. 
 | 
| net.bytebuddy.implementation.bytecode | 
 Types and classes in this package are responsible for creating Java byte code for a given byte code target
 which is represented by a  
MethodDescription. | 
| net.bytebuddy.implementation.bytecode.assign | 
 An  
Assigner is responsible for transforming
 a given TypeDescription into another one. | 
| net.bytebuddy.implementation.bytecode.assign.primitive | 
Assigner implementations of this package
 are capable of handling primitive types or the void type. | 
| net.bytebuddy.implementation.bytecode.collection | 
 This package is dedicated to creating  
StackManipulations
 that create collections or arrays from a given number of values. | 
| net.bytebuddy.implementation.bytecode.constant | 
StackManipulations in this package are responsible for
 creating compile-time constants and pushing them onto the operand stack. | 
| net.bytebuddy.implementation.bytecode.member | 
StackManipulations of this package are responsible for
 accessing type or method members, i.e. | 
| net.bytebuddy.utility.visitor | 
 A package containing visitor classes for ASM. 
 | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Context.Factory
 A factory for creating a new implementation context. 
 | 
| Implementation.Target
 The target of an implementation. 
 | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.SpecialMethodInvocation
 Represents a 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.Target
 The target of an implementation. 
 | 
| LoadedTypeInitializer
 Implementations of this interface explicitly initialize a loaded type. 
 | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Target
 The target of an implementation. 
 | 
| Class and Description | 
|---|
| EqualsMethod
 An implementation of  
Object.equals(Object) that takes a class's declared fields into consideration. | 
| HashCodeMethod
 An implementation of  
Object.hashCode() that takes a class's declared fields into consideration. | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Context.FrameGeneration
 Indicates the frame generation being applied. 
 | 
| ToStringMethod.PrefixResolver.Default
 Default implementations for a prefix resolver. 
 | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Context.Factory
 A factory for creating a new implementation context. 
 | 
| LoadedTypeInitializer
 Implementations of this interface explicitly initialize a loaded type. 
 | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Context.ExtractableView
 Represents an extractable view of an  
Implementation.Context which
 allows the retrieval of any registered auxiliary type. | 
| Implementation.Context.Factory
 A factory for creating a new implementation context. 
 | 
| Implementation.Target
 The target of an implementation. 
 | 
| Implementation.Target.Factory
 A factory for creating an  
Implementation.Target. | 
| LoadedTypeInitializer
 Implementations of this interface explicitly initialize a loaded type. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Context.Factory
 A factory for creating a new implementation context. 
 | 
| Implementation.SpecialMethodInvocation
 Represents a 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.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. | 
| LoadedTypeInitializer
 Implementations of this interface explicitly initialize a loaded type. 
 | 
| Class and Description | 
|---|
| Implementation.Context.Factory
 A factory for creating a new implementation context. 
 | 
| Implementation.SpecialMethodInvocation
 Represents a 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.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. | 
| Class and Description | 
|---|
| EqualsMethod
 An implementation of  
Object.equals(Object) that takes a class's declared fields into consideration. | 
| 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.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. 
 | 
| ExceptionMethod.ConstructionDelegate
 A construction delegate is responsible for calling a  
Throwable's constructor. | 
| 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.Prepared
 A prepared 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.ForSetter
 A field accessor for a field setter. 
 | 
| 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. 
 | 
| 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.ForNullValue
 A fixed value of  
null. | 
| HashCodeMethod
 An implementation of  
Object.hashCode() that takes a class's declared fields into consideration. | 
| HashCodeMethod.NullValueGuard
 A guard against  
null values for fields with reference types. | 
| HashCodeMethod.NullValueGuard.NoOp
 A non-operational null value guard. 
 | 
| HashCodeMethod.OffsetProvider
 An offset provider is responsible for supplying the initial hash code. 
 | 
| HashCodeMethod.OffsetProvider.ForDynamicTypeHash
 An offset provider that uses the instance's class's hash code. 
 | 
| HashCodeMethod.OffsetProvider.ForStaticTypeHash
 An offset provider that uses the instrumented type's class constant's hash code. 
 | 
| 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. | 
| 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.Context
 The context for an implementation application. 
 | 
| Implementation.Context.Default.AbstractPropertyAccessorMethod
 A base implementation of a method that accesses a property of an instrumented type. 
 | 
| 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
 that uses a random suffix for accessors. | 
| 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.Context.FrameGeneration
 Indicates the frame generation being applied. 
 | 
| Implementation.Simple.Dispatcher
 A dispatcher for a simple  
Implementation, typically implemented as a lambda expression. | 
| Implementation.SpecialMethodInvocation
 Represents a 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.Target
 The target of an implementation. 
 | 
| Implementation.Target.AbstractBase.DefaultMethodInvocation
 Determines if default method invocations are possible. 
 | 
| InvocationHandlerAdapter
 An adapter for adapting an  
InvocationHandler. | 
| InvocationHandlerAdapter.AssignerConfigurable
 Allows for the configuration of an  
Assigner
 of an InvocationHandlerAdapter. | 
| 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.ForField
 Provides an argument from an existing field. 
 | 
| 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.ForMethodParameter
 An argument provider that loads an argument of the intercepted method. 
 | 
| InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved | 
| 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.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.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.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. | 
| LoadedTypeInitializer
 Implementations of this interface explicitly initialize a loaded type. 
 | 
| LoadedTypeInitializer.NoOp
 A loaded type initializer that does not do anything. 
 | 
| 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. 
 | 
| MethodCall
 This  
Implementation allows the invocation of a specified method while
 providing explicit arguments to this method. | 
| MethodCall.Appender
 The appender being used to implement a  
MethodCall. | 
| 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.ForInstrumentedType.Factory
 A factory for an argument loader that supplies the instrumented type 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.ForInstrumentedMethod
 A factory that creates an arguments loader that loads all parameters of the instrumented method contained in an array. 
 | 
| MethodCall.ArgumentLoader.ForNullConstant
 An argument loader that loads the  
null value onto the operand stack. | 
| 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.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.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.ForField.Location
 A location of a field. 
 | 
| MethodCall.TargetHandler.ForSelfOrStaticInvocation.Factory
 A factory for invoking a static method or a self-declared method. 
 | 
| MethodCall.TargetHandler.Resolved
 A resolved target handler. 
 | 
| 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.Simple
 Simple termination handler implementations. 
 | 
| MethodCall.WithoutSpecifiedTarget
 Represents a  
MethodCall that invokes a method without specifying
 an invocation method. | 
| MethodDelegation
 This implementation delegates a 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.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.ForField
 An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type. 
 | 
| MethodDelegation.WithCustomProperties
 A  
MethodDelegation with custom configuration. | 
| StubMethod
 This implementation creates a method stub which does nothing but returning the default value of the return
 type of the method. 
 | 
| SuperMethodCall
 This implementation will create a new method which simply calls its super method. 
 | 
| 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. 
 | 
| 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.ValueConsumer
 A value consumer that is responsible for adding a field value to the string creating  
StringBuilder. | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.SpecialMethodInvocation
 Represents a 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.Target
 The target of an implementation. 
 | 
| MethodAccessorFactory
 A factory for creating method proxies for an auxiliary type. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.Target
 The target of an implementation. 
 | 
| Class and Description | 
|---|
| Implementation
 An implementation is responsible for implementing methods of a dynamically created type as byte code. 
 | 
| Implementation.Context
 The context for an implementation application. 
 | 
| Implementation.SpecialMethodInvocation
 Represents a 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.Target
 The target of an implementation. 
 | 
| MethodAccessorFactory
 A factory for creating method proxies for an auxiliary type. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Class and Description | 
|---|
| Implementation.Context
 The context for an implementation application. 
 | 
| Class and Description | 
|---|
| LoadedTypeInitializer
 Implementations of this interface explicitly initialize a loaded type. 
 | 
Copyright © 2014–2023. All rights reserved.