| Package | Description | 
|---|---|
| net.bytebuddy.asm | 
 The ASM package contains classes that are meant for direct interaction with the ASM API. 
 | 
| net.bytebuddy.description.field | 
 Contains descriptions of Java fields. 
 | 
| net.bytebuddy.description.method | 
 Contains descriptions of Java methods and constructors as well as their parameters. 
 | 
| net.bytebuddy.description.type | 
 Contains descriptions of Java types and packages. 
 | 
| 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.implementation | 
 The implementation package contains any logic for intercepting method calls. 
 | 
| net.bytebuddy.matcher | 
 Contains an API for matching Java byte code entities. 
 | 
| net.bytebuddy.pool | 
 Classes of this package allow for the creating  
TypeDescriptions without
 loading any classes. | 
| net.bytebuddy.utility | 
 This package contains utility classes for common use within any Byte Buddy logic. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
FieldDescription | 
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result)
Resolves the field to substitute with. 
 | 
FieldDescription | 
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.Simple.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result)
Resolves the field to substitute with. 
 | 
FieldDescription | 
MemberSubstitution.Substitution.ForFieldAccess.FieldResolver.ForElementMatcher.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result)
Resolves the field to substitute with. 
 | 
MethodDescription | 
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result)
Resolves the method to substitute with. 
 | 
MethodDescription | 
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Simple.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result)
Resolves the method to substitute with. 
 | 
MethodDescription | 
MemberSubstitution.Substitution.ForMethodInvocation.MethodResolver.Matching.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result)
Resolves the method to substitute with. 
 | 
StackManipulation | 
MemberSubstitution.Substitution.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result,
       int freeOffset)
Resolves this substitution into a stack manipulation. 
 | 
StackManipulation | 
MemberSubstitution.Substitution.Stubbing.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result,
       int freeOffset)
Resolves this substitution into a stack manipulation. 
 | 
StackManipulation | 
MemberSubstitution.Substitution.ForFieldAccess.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result,
       int freeOffset)
Resolves this substitution into a stack manipulation. 
 | 
StackManipulation | 
MemberSubstitution.Substitution.ForMethodInvocation.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result,
       int freeOffset)
Resolves this substitution into a stack manipulation. 
 | 
StackManipulation | 
MemberSubstitution.Substitution.Chain.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic result,
       int freeOffset)
Resolves this substitution into a stack manipulation. 
 | 
MemberSubstitution.Substitution.Chain.Step.Resolution | 
MemberSubstitution.Substitution.Chain.Step.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic current,
       Map<Integer,Integer> offsets,
       int freeOffset)
Resolves this step of a substitution chain. 
 | 
MemberSubstitution.Substitution.Chain.Step.Resolution | 
MemberSubstitution.Substitution.Chain.Step.Simple.resolve(TypeDescription targetType,
       ByteCodeElement target,
       TypeList.Generic parameters,
       TypeDescription.Generic current,
       Map<Integer,Integer> offsets,
       int freeOffset)
Resolves this step of a substitution chain. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
MemberSubstitution.WithoutSpecification | 
MemberSubstitution.element(ElementMatcher<? super ByteCodeElement> matcher)
Substitutes any interaction with a field or method that matches the given matcher. 
 | 
protected static MemberSubstitution.Replacement.Factory | 
MemberSubstitution.Replacement.ForElementMatchers.Factory.of(ElementMatcher<? super ByteCodeElement> matcher,
  MemberSubstitution.Substitution.Factory factory)
Creates a factory for applying a substitution on all matched byte code elements for all access types. 
 | 
| Constructor and Description | 
|---|
Resolved(TypeDescription targetType,
        ByteCodeElement target,
        MemberSubstitution.Substitution substitution)
Creates a new resolved binding. 
 | 
| Constructor and Description | 
|---|
ForMatchedByteCodeElement(MethodGraph.Compiler methodGraphCompiler,
                         MemberSubstitution.TypePoolResolver typePoolResolver,
                         boolean strict,
                         MemberSubstitution.Replacement.Factory replacementFactory,
                         ElementMatcher<? super ByteCodeElement> matcher)
Creates a new member substitution for a matched byte code element that requires a specification for how to perform a substitution. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
FieldDescription
Implementations of this interface describe a Java field. 
 | 
static interface  | 
FieldDescription.InDefinedShape
Represents a field in its defined shape, i.e. 
 | 
static interface  | 
FieldDescription.InGenericShape
Represents a field description in its generic shape, i.e. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
FieldDescription.AbstractBase
An abstract base implementation of a field description. 
 | 
static class  | 
FieldDescription.ForLoadedField
An implementation of a field description for a loaded field. 
 | 
static class  | 
FieldDescription.InDefinedShape.AbstractBase
An abstract base implementation of a field description in its defined shape. 
 | 
static class  | 
FieldDescription.Latent
A latent field description describes a field that is not attached to a declaring
  
TypeDescription. | 
static class  | 
FieldDescription.TypeSubstituting
A field description that represents a given field but with a substituted field type. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
MethodDescription
Implementations of this interface describe a Java method, i.e. 
 | 
static interface  | 
MethodDescription.InDefinedShape
Represents a method in its defined shape, i.e. 
 | 
static interface  | 
MethodDescription.InGenericShape
Represents a method description in its generic shape, i.e. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
MethodDescription.AbstractBase
An abstract base implementation of a method description. 
 | 
static class  | 
MethodDescription.ForLoadedConstructor
An implementation of a method description for a loaded constructor. 
 | 
static class  | 
MethodDescription.ForLoadedMethod
An implementation of a method description for a loaded method. 
 | 
static class  | 
MethodDescription.InDefinedShape.AbstractBase
An abstract base implementation of a method description in its defined shape. 
 | 
protected static class  | 
MethodDescription.InDefinedShape.AbstractBase.ForLoadedExecutable<T extends AnnotatedElement>
A base implementation for a loaded instance representation for a  
java.lang.reflect.Executable. | 
static class  | 
MethodDescription.Latent
A latent method description describes a method that is not attached to a declaring
  
TypeDescription. | 
static class  | 
MethodDescription.Latent.TypeInitializer
A method description that represents the type initializer. 
 | 
static class  | 
MethodDescription.TypeSubstituting
A method description that represents a given method but with substituted method types. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
TypeDescription
Implementations of this interface represent a Java type, i.e. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
TypeDescription.AbstractBase
An abstract base implementation of a type description. 
 | 
static class  | 
TypeDescription.AbstractBase.OfSimpleType
An adapter implementation of a  
TypeDescription that
 describes any type that is not an array or a primitive type. | 
static class  | 
TypeDescription.AbstractBase.OfSimpleType.WithDelegation
An implementation of a type description that delegates all properties but the type's name to a delegate. 
 | 
static class  | 
TypeDescription.ArrayProjection
A projection for an array type based on an existing  
TypeDescription. | 
static class  | 
TypeDescription.ForLoadedType
A type description implementation that represents a loaded type. 
 | 
static class  | 
TypeDescription.ForPackageDescription
A type representation of a package description. 
 | 
static class  | 
TypeDescription.Latent
 A latent type description for a type without methods or fields. 
 | 
static class  | 
TypeDescription.SuperTypeLoading
A delegating type description that always attempts to load the super types of a delegate type. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
protected static class  | 
Transformer.ForField.TransformedField
An implementation of a transformed field. 
 | 
protected static class  | 
Transformer.ForMethod.TransformedMethod
The transformed method. 
 | 
| Modifier and Type | Interface and Description | 
|---|---|
interface  | 
InstrumentedType
Implementations of this interface represent an instrumented type that is subject to change. 
 | 
static interface  | 
InstrumentedType.WithFlexibleName
Implementations represent an  
InstrumentedType with a flexible name. | 
| Modifier and Type | Class and Description | 
|---|---|
static class  | 
InstrumentedType.Default
A default implementation of an instrumented type. 
 | 
static class  | 
InstrumentedType.Frozen
A frozen representation of an instrumented type of which the structure must not be modified. 
 | 
protected static class  | 
TypeWriter.MethodPool.Record.AccessBridgeWrapper.AccessorBridge
A method representing an accessor bridge method. 
 | 
protected static class  | 
TypeWriter.MethodPool.Record.AccessBridgeWrapper.BridgeTarget
A method representing a bridge's target method in its defined shape. 
 | 
protected static class  | 
TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge.VisibilityBridge
A method describing a visibility bridge. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
protected static class  | 
MethodRebaseResolver.Resolution.ForRebasedConstructor.RebasedConstructor
An description of a rebased constructor. 
 | 
protected static class  | 
MethodRebaseResolver.Resolution.ForRebasedMethod.RebasedMethod
A description of a rebased method. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
protected static class  | 
Implementation.Context.Default.AbstractPropertyAccessorMethod
A base implementation of a method that accesses a property of an instrumented type. 
 | 
protected static class  | 
Implementation.Context.Default.AccessorMethod
A description of an accessor method to access another method from outside the instrumented type. 
 | 
protected static class  | 
Implementation.Context.Default.CacheValueField
A description of a field that stores a cached value. 
 | 
protected static class  | 
Implementation.Context.Default.FieldGetter
A description of a field getter method. 
 | 
protected static class  | 
Implementation.Context.Default.FieldSetter
A description of a field setter method. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
AccessibilityMatcher<T extends ByteCodeElement>
An element matcher that validates that a given byte code element is accessible to a given type. 
 | 
class  | 
VisibilityMatcher<T extends ByteCodeElement>
An element matcher that validates that a given byte code element is visible to a given type. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static <T extends ByteCodeElement> | 
ElementMatchers.isAccessibleTo(Class<?> type)
Matches a  
ByteCodeElement that is accessible to a given Class. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isAccessibleTo(TypeDescription type)
Matches a  
ByteCodeElement that is accessible to a given Class. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isDeclaredBy(Class<?> type)
Matches a  
ByteCodeElement for being declared by a given Class. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isDeclaredBy(ElementMatcher<? super TypeDescription> matcher)
Matches a  
ByteCodeElement for being declared by a TypeDescription that is matched by the given matcher. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isDeclaredBy(TypeDescription type)
Matches a  
ByteCodeElement for being declared by a given TypeDescription. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isDeclaredByGeneric(ElementMatcher<? super TypeDescription.Generic> matcher)
Matches a  
ByteCodeElement for being declared by a TypeDescription.Generic that is matched by the given matcher. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isDeclaredByGeneric(Type type)
Matches a  
ByteCodeElement for being declared by a given generic Type. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isDeclaredByGeneric(TypeDescription.Generic type)
Matches a  
ByteCodeElement for being declared by a given TypeDescription.Generic. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isVisibleTo(Class<?> type)
Matches a  
ByteCodeElement that is visible to a given Class. | 
static <T extends ByteCodeElement> | 
ElementMatchers.isVisibleTo(TypeDescription type)
Matches a  
ByteCodeElement that is visible to a given TypeDescription. | 
| Modifier and Type | Class and Description | 
|---|---|
protected static class  | 
TypePool.Default.LazyTypeDescription
A type description that looks up any referenced  
ByteCodeElement or
 AnnotationDescription by querying a type pool at lookup time. | 
protected class  | 
TypePool.Default.WithLazyResolution.LazyTypeDescription
A lazy type description that resolves any property that is not the name only when requested. 
 | 
protected static class  | 
TypePool.LazyFacade.LazyTypeDescription
A description of a type that delegates to another type pool once a property that is not the name is resolved. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
protected static class  | 
JavaType.LatentTypeWithSimpleName
A latent type that resolves the simple name without considering the declaring type which is not normally available. 
 | 
Copyright © 2014–2023. All rights reserved.