Uses of Interface
net.bytebuddy.description.type.TypeDescription

Packages that use TypeDescription

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.description	Classes of this package allow the representation of Java classes, their member and their meta data.
net.bytebuddy.description.annotation	Contains descriptions of annotations and annotation values.
net.bytebuddy.description.enumeration	A package that contains classes for describing enumeration values.
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.loading	This package contains classes that are responsible for class loading of classes that are represented by byte arrays.
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.attribute	All types and classes in this package are responsible for writing attributes for a given Java byte code element, i.e.
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.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.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.

Uses of TypeDescription in net.bytebuddy

Methods in net.bytebuddy with parameters of type TypeDescription

Modifier and Type	Method	Description
protected abstract java.lang.String	NamingStrategy.AbstractBase.name(TypeDescription superClass)	Determines a new name when creating a new type that subclasses the provided type.
protected java.lang.String	NamingStrategy.PrefixingRandom.name(TypeDescription superClass)
protected java.lang.String	NamingStrategy.SuffixingRandom.name(TypeDescription superClass)
static ClassFileVersion	ClassFileVersion.of(TypeDescription typeDescription, ClassFileLocator classFileLocator)	Extracts a class' class version.
<T> DynamicType.Builder<T>	ByteBuddy.rebase(TypeDescription type, ClassFileLocator classFileLocator)	Rebases the given type where any intercepted method that is declared by the redefined type is preserved within the rebased type's class such that the class's original can be invoked from the new method implementations.
<T> DynamicType.Builder<T>	ByteBuddy.rebase(TypeDescription type, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer)	Rebases the given type where any intercepted method that is declared by the redefined type is preserved within the rebased type's class such that the class's original can be invoked from the new method implementations.
java.lang.String	NamingStrategy.AbstractBase.rebase(TypeDescription typeDescription)
java.lang.String	NamingStrategy.rebase(TypeDescription typeDescription)	Determines a name for the dynamic type when rebasing the provided type.
<T> DynamicType.Builder<T>	ByteBuddy.redefine(TypeDescription type, ClassFileLocator classFileLocator)	Redefines the given type where any intercepted method that is declared by the redefined type is fully replaced by the new implementation.
java.lang.String	NamingStrategy.AbstractBase.redefine(TypeDescription typeDescription)
java.lang.String	NamingStrategy.redefine(TypeDescription typeDescription)	Determines a name for the dynamic type when redefining the provided type.
java.lang.String	NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue.resolve(TypeDescription typeDescription)
java.lang.String	NamingStrategy.SuffixingRandom.BaseNameResolver.ForGivenType.resolve(TypeDescription typeDescription)
java.lang.String	NamingStrategy.SuffixingRandom.BaseNameResolver.ForUnnamedType.resolve(TypeDescription typeDescription)
java.lang.String	NamingStrategy.SuffixingRandom.BaseNameResolver.resolve(TypeDescription typeDescription)	Resolves the base name for a given type description.

Constructors in net.bytebuddy with parameters of type TypeDescription

Constructor	Description
ForGivenType(TypeDescription typeDescription)	Creates a new base name resolver that resolves a using the name of a given type.
ValuesMethodAppender(TypeDescription instrumentedType)	Creates a new appender for the values method.

Uses of TypeDescription in net.bytebuddy.agent.builder

Methods in net.bytebuddy.agent.builder that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	AgentBuilder.DescriptionStrategy.apply(java.lang.String typeName, java.lang.Class<?> type, TypePool typePool, AgentBuilder.CircularityLock circularityLock, java.lang.ClassLoader classLoader, JavaModule module)	Describes the given type.
TypeDescription	AgentBuilder.DescriptionStrategy.SuperTypeLoading.apply(java.lang.String typeName, java.lang.Class<?> type, TypePool typePool, AgentBuilder.CircularityLock circularityLock, java.lang.ClassLoader classLoader, JavaModule module)
TypeDescription	AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.apply(java.lang.String typeName, java.lang.Class<?> type, TypePool typePool, AgentBuilder.CircularityLock circularityLock, java.lang.ClassLoader classLoader, JavaModule module)

Methods in net.bytebuddy.agent.builder with parameters of type TypeDescription

Modifier and Type	Method	Description
DynamicType.Builder<?>	AgentBuilder.TypeStrategy.builder(TypeDescription typeDescription, ByteBuddy byteBuddy, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer)	Creates a type builder for a given type.
DynamicType.Builder<?>	AgentBuilder.TypeStrategy.ForBuildEntryPoint.builder(TypeDescription typeDescription, ByteBuddy byteBuddy, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer)
protected void	AgentBuilder.RedefinitionStrategy.Collector.consider(AgentBuilder.RawMatcher typeMatcher, AgentBuilder.RawMatcher ignoredTypeMatcher, AgentBuilder.Listener listener, TypeDescription typeDescription, java.lang.Class<?> type, java.lang.Class<?> classBeingRedefined, JavaModule module, boolean unmodifiable)	Does consider the retransformation or redefinition of a loaded type.
protected void	AgentBuilder.RedefinitionStrategy.Collector.consider(AgentBuilder.RawMatcher typeMatcher, AgentBuilder.RawMatcher ignoredTypeMatcher, AgentBuilder.Listener listener, TypeDescription typeDescription, java.lang.Class<?> type, JavaModule module)	Does consider the retransformation or redefinition of a loaded type without a loaded type representation.
boolean	AgentBuilder.Default.Transformation.Compound.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.Default.Transformation.Ignored.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.Default.Transformation.Simple.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.Conjunction.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.Disjunction.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.ForElementMatchers.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.ForLoadState.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.ForResolvableTypes.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.Inversion.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
boolean	AgentBuilder.RawMatcher.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)	Decides if the given typeDescription should be instrumented with the entailed AgentBuilder.Transformers.
boolean	AgentBuilder.RawMatcher.Trivial.matches(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, java.security.ProtectionDomain protectionDomain)
void	AgentBuilder.Listener.Adapter.onIgnored(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)
void	AgentBuilder.Listener.Compound.onIgnored(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)
void	AgentBuilder.Listener.Filtering.onIgnored(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)
void	AgentBuilder.Listener.NoOp.onIgnored(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)
void	AgentBuilder.Listener.onIgnored(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)	Invoked when a type is not transformed but ignored.
void	AgentBuilder.Listener.StreamWriting.onIgnored(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)
void	AgentBuilder.Listener.Adapter.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
void	AgentBuilder.Listener.Compound.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
void	AgentBuilder.Listener.Filtering.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
void	AgentBuilder.Listener.ModuleReadEdgeCompleting.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
void	AgentBuilder.Listener.NoOp.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
void	AgentBuilder.Listener.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)	Invoked prior to a successful transformation being applied.
void	AgentBuilder.Listener.StreamWriting.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
void	AgentBuilder.Listener.WithTransformationsOnly.onTransformation(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded, DynamicType dynamicType)
AgentBuilder.Default.Transformation.Resolution	AgentBuilder.Default.Transformation.Compound.resolve(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, boolean loaded, java.security.ProtectionDomain protectionDomain, TypePool typePool)
AgentBuilder.Default.Transformation.Resolution	AgentBuilder.Default.Transformation.Ignored.resolve(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, boolean loaded, java.security.ProtectionDomain protectionDomain, TypePool typePool)
AgentBuilder.Default.Transformation.Resolution	AgentBuilder.Default.Transformation.resolve(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, boolean loaded, java.security.ProtectionDomain protectionDomain, TypePool typePool)	Resolves an attempted transformation to a specific transformation.
AgentBuilder.Default.Transformation.Resolution	AgentBuilder.Default.Transformation.Simple.resolve(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.lang.Class<?> classBeingRedefined, boolean loaded, java.security.ProtectionDomain protectionDomain, TypePool typePool)
DynamicType.Builder<?>	AgentBuilder.Transformer.Compound.transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module)
DynamicType.Builder<?>	AgentBuilder.Transformer.ForAdvice.transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module)
DynamicType.Builder<?>	AgentBuilder.Transformer.ForBuildPlugin.transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module)
DynamicType.Builder<?>	AgentBuilder.Transformer.NoOp.transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module)
DynamicType.Builder<?>	AgentBuilder.Transformer.transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module)	Allows for a transformation of a DynamicType.Builder.
org.objectweb.asm.MethodVisitor	AgentBuilder.LambdaInstrumentationStrategy.AlternativeMetaFactoryRedirection.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags)
org.objectweb.asm.MethodVisitor	AgentBuilder.LambdaInstrumentationStrategy.MetaFactoryRedirection.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags)

Method parameters in net.bytebuddy.agent.builder with type arguments of type TypeDescription

Modifier and Type	Method	Description
S	AgentBuilder.Matchable.AbstractBase.and(ElementMatcher<? super TypeDescription> typeMatcher)
S	AgentBuilder.Matchable.AbstractBase.and(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)
S	AgentBuilder.Matchable.AbstractBase.and(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)
T	AgentBuilder.Matchable.and(ElementMatcher<? super TypeDescription> typeMatcher)	Defines a matching that is positive if both the previous matcher and the supplied matcher are matched.
T	AgentBuilder.Matchable.and(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)	Defines a matching that is positive if both the previous matcher and the supplied matcher are matched.
T	AgentBuilder.Matchable.and(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)	Defines a matching that is positive if both the previous matcher and the supplied matcher are matched.
AgentBuilder.Ignored	AgentBuilder.Default.Delegator.ignore(ElementMatcher<? super TypeDescription> ignoredTypes)
AgentBuilder.Ignored	AgentBuilder.Default.Delegator.ignore(ElementMatcher<? super TypeDescription> ignoredTypes, ElementMatcher<? super java.lang.ClassLoader> ignoredClassLoaders)
AgentBuilder.Ignored	AgentBuilder.Default.Delegator.ignore(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)
AgentBuilder.Ignored	AgentBuilder.Default.ignore(ElementMatcher<? super TypeDescription> typeMatcher)
AgentBuilder.Ignored	AgentBuilder.Default.ignore(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)
AgentBuilder.Ignored	AgentBuilder.Default.ignore(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)
AgentBuilder.Ignored	AgentBuilder.ignore(ElementMatcher<? super TypeDescription> typeMatcher)	Excludes any type that is matched by the provided matcher from instrumentation and considers types by all ClassLoaders.
AgentBuilder.Ignored	AgentBuilder.ignore(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)	Excludes any type that is matched by the provided matcher and is loaded by a class loader matching the second matcher.
AgentBuilder.Ignored	AgentBuilder.ignore(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)	Excludes any type that is matched by the provided matcher and is loaded by a class loader matching the second matcher.
S	AgentBuilder.Matchable.AbstractBase.or(ElementMatcher<? super TypeDescription> typeMatcher)
S	AgentBuilder.Matchable.AbstractBase.or(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)
S	AgentBuilder.Matchable.AbstractBase.or(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)
T	AgentBuilder.Matchable.or(ElementMatcher<? super TypeDescription> typeMatcher)	Defines a matching that is positive if the previous matcher or the supplied matcher are matched.
T	AgentBuilder.Matchable.or(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)	Defines a matching that is positive if the previous matcher or the supplied matcher are matched.
T	AgentBuilder.Matchable.or(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)	Defines a matching that is positive if the previous matcher or the supplied matcher are matched.
AgentBuilder.Identified.Narrowable	AgentBuilder.Default.Delegator.type(ElementMatcher<? super TypeDescription> typeMatcher)
AgentBuilder.Identified.Narrowable	AgentBuilder.Default.Delegator.type(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)
AgentBuilder.Identified.Narrowable	AgentBuilder.Default.Delegator.type(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)
AgentBuilder.Identified.Narrowable	AgentBuilder.Default.type(ElementMatcher<? super TypeDescription> typeMatcher)
AgentBuilder.Identified.Narrowable	AgentBuilder.Default.type(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)
AgentBuilder.Identified.Narrowable	AgentBuilder.Default.type(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)
AgentBuilder.Identified.Narrowable	AgentBuilder.type(ElementMatcher<? super TypeDescription> typeMatcher)	Matches a type being loaded in order to apply the supplied AgentBuilder.Transformers before loading this type.
AgentBuilder.Identified.Narrowable	AgentBuilder.type(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)	Matches a type being loaded in order to apply the supplied AgentBuilder.Transformers before loading this type.
AgentBuilder.Identified.Narrowable	AgentBuilder.type(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)	Matches a type being loaded in order to apply the supplied AgentBuilder.Transformers before loading this type.

Constructors in net.bytebuddy.agent.builder with parameters of type TypeDescription

Constructor	Description
Appender(TypeDescription instrumentedType)	Creates a new appender.
InjectingInitializer(TypeDescription instrumentedType, java.util.Map<TypeDescription,byte[]> rawAuxiliaryTypes, java.util.Map<TypeDescription,LoadedTypeInitializer> loadedTypeInitializers, ClassInjector classInjector)	Creates a new injection initializer.
Resolution(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, java.security.ProtectionDomain protectionDomain, boolean loaded, TypePool typePool, AgentBuilder.Transformer transformer, boolean decorator)	Creates a new active transformation.
SerializationImplementation(TypeDescription targetType, TypeDescription lambdaType, java.lang.String lambdaMethodName, JavaConstant.MethodType lambdaMethod, JavaConstant.MethodHandle targetMethod, JavaConstant.MethodType specializedMethod)	Creates a new implementation for a serializable's lambda expression's writeReplace method.
Unresolved(TypeDescription typeDescription, java.lang.ClassLoader classLoader, JavaModule module, boolean loaded)	Creates a new unresolved resolution.

Constructor parameters in net.bytebuddy.agent.builder with type arguments of type TypeDescription

Constructor	Description
ForElementMatchers(ElementMatcher<? super TypeDescription> typeMatcher)	Creates a new AgentBuilder.RawMatcher that only matches the supplied TypeDescription against a supplied matcher.
ForElementMatchers(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher)	Creates a new AgentBuilder.RawMatcher that only matches the supplied TypeDescription and its ClassLoader against two matcher in order to decided if an instrumentation should be conducted.
ForElementMatchers(ElementMatcher<? super TypeDescription> typeMatcher, ElementMatcher<? super java.lang.ClassLoader> classLoaderMatcher, ElementMatcher<? super JavaModule> moduleMatcher)	Creates a new AgentBuilder.RawMatcher that only matches the supplied TypeDescription, its ClassLoader and module against element suitable matchers.
ForMatchedGrouping(java.util.Collection<? extends ElementMatcher<? super TypeDescription>> matchers)	Creates a new batch allocator that groups all batches by discriminating types using a type matcher.
InjectingInitializer(TypeDescription instrumentedType, java.util.Map<TypeDescription,byte[]> rawAuxiliaryTypes, java.util.Map<TypeDescription,LoadedTypeInitializer> loadedTypeInitializers, ClassInjector classInjector)	Creates a new injection initializer.

Uses of TypeDescription in net.bytebuddy.asm

Fields in net.bytebuddy.asm declared as TypeDescription

Modifier and Type	Field	Description
protected TypeDescription	Advice.Dispatcher.Inlining.Resolved.AdviceMethodInliner.instrumentedType	A description of the instrumented type.
protected TypeDescription	Advice.StackMapFrameHandler.Default.instrumentedType	The instrumented type.

Fields in net.bytebuddy.asm with type parameters of type TypeDescription

Modifier and Type	Field	Description
protected java.util.List<? extends TypeDescription>	Advice.StackMapFrameHandler.Default.ForAdvice.endTypes	The types provided after execution of the advice code.
protected java.util.List<? extends TypeDescription>	Advice.MethodSizeHandler.Default.enterTypes	A list of virtual method arguments that are available before the instrumented method is executed.
protected java.util.List<? extends TypeDescription>	Advice.StackMapFrameHandler.Default.enterTypes	A list of virtual method arguments that are available before the instrumented method is executed.
protected java.util.List<? extends TypeDescription>	Advice.MethodSizeHandler.Default.exitTypes	A list of virtual method arguments that are available after the instrumented method has completed.
protected java.util.List<? extends TypeDescription>	Advice.StackMapFrameHandler.Default.exitTypes	A list of virtual method arguments that are available after the instrumented method has completed.
protected java.util.List<? extends TypeDescription>	Advice.StackMapFrameHandler.Default.ForAdvice.startTypes	The types provided before execution of the advice code.

Methods in net.bytebuddy.asm that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	Advice.Dispatcher.Delegating.getAdviceType()
TypeDescription	Advice.Dispatcher.Inactive.getAdviceType()
TypeDescription	Advice.Dispatcher.Inlining.getAdviceType()
TypeDescription	Advice.Dispatcher.Unresolved.getAdviceType()	The type that is produced as a result of executing this advice method.
TypeDescription	Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithExceptionHandler.getThrowable()
TypeDescription	Advice.Dispatcher.Delegating.Resolved.ForMethodExit.WithoutExceptionHandler.getThrowable()
TypeDescription	Advice.Dispatcher.Inactive.getThrowable()
TypeDescription	Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithExceptionHandler.getThrowable()
TypeDescription	Advice.Dispatcher.Inlining.Resolved.ForMethodExit.WithoutExceptionHandler.getThrowable()
TypeDescription	Advice.Dispatcher.Resolved.ForMethodExit.getThrowable()	Returns the type of throwable for which this exit advice is supposed to be invoked.

Methods in net.bytebuddy.asm with parameters of type TypeDescription

Modifier and Type	Method	Description
protected abstract org.objectweb.asm.MethodVisitor	Advice.Dispatcher.Inlining.Resolved.apply(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.SuppressionHandler.Bound suppressionHandler, Advice.Dispatcher.RelocationHandler.Bound relocationHandler)	Applies a resolution for a given instrumented method.
protected org.objectweb.asm.MethodVisitor	Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.apply(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.SuppressionHandler.Bound suppressionHandler, Advice.Dispatcher.RelocationHandler.Bound relocationHandler)
protected org.objectweb.asm.MethodVisitor	Advice.Dispatcher.Inlining.Resolved.ForMethodExit.apply(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.SuppressionHandler.Bound suppressionHandler, Advice.Dispatcher.RelocationHandler.Bound relocationHandler)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Returns a string representation for this renderer.
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForConstantValue.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForDescriptor.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForJavaSignature.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForMethodName.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForReturnTypeName.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForStringRepresentation.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
java.lang.String	Advice.OffsetMapping.ForOrigin.Renderer.ForTypeName.apply(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
StackManipulation	MemberSubstitution.Substitution.Resolver.apply(TypeDescription instrumentedType, ByteCodeElement target, TypeList.Generic arguments, TypeDescription.Generic result)	Applies this resolver.
StackManipulation	MemberSubstitution.Substitution.Resolver.FieldAccessing.apply(TypeDescription instrumentedType, ByteCodeElement target, TypeList.Generic arguments, TypeDescription.Generic result)
StackManipulation	MemberSubstitution.Substitution.Resolver.MethodInvoking.apply(TypeDescription instrumentedType, ByteCodeElement target, TypeList.Generic arguments, TypeDescription.Generic result)
StackManipulation	MemberSubstitution.Substitution.Resolver.Stubbing.apply(TypeDescription instrumentedType, ByteCodeElement target, TypeList.Generic arguments, TypeDescription.Generic result)
StackManipulation	MemberSubstitution.Substitution.Resolver.Unresolved.apply(TypeDescription instrumentedType, ByteCodeElement target, TypeList.Generic arguments, TypeDescription.Generic result)
Advice.Dispatcher.Bound	Advice.Dispatcher.Delegating.Resolved.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Advice.Dispatcher.Bound	Advice.Dispatcher.Inactive.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Advice.Dispatcher.Bound	Advice.Dispatcher.Inlining.Resolved.ForMethodEnter.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Advice.Dispatcher.Bound	Advice.Dispatcher.Inlining.Resolved.ForMethodExit.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
Advice.Dispatcher.Bound	Advice.Dispatcher.Resolved.bind(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)	Binds this dispatcher for resolution to a specific method.
<T extends java.lang.annotation.Annotation> Advice.WithCustomMapping	Advice.WithCustomMapping.bind(java.lang.Class<T> type, TypeDescription value)	Binds the supplied annotation to the supplied type constant.
protected abstract int	Advice.StackMapFrameHandler.Default.TranslationMode.copy(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription methodDescription, java.lang.Object[] localVariable, java.lang.Object[] translated)	Copies the fixed parameters of the instrumented method onto the operand stack.
protected org.objectweb.asm.MethodVisitor	Advice.doWrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, int writerFlags, int readerFlags)	Wraps the method visitor to implement this advice.
protected abstract FieldLocator	Advice.OffsetMapping.ForField.Unresolved.fieldLocator(TypeDescription instrumentedType)	Returns a field locator for this instance.
protected FieldLocator	Advice.OffsetMapping.ForField.Unresolved.WithExplicitType.fieldLocator(TypeDescription instrumentedType)
protected FieldLocator	Advice.OffsetMapping.ForField.Unresolved.WithImplicitType.fieldLocator(TypeDescription instrumentedType)
protected abstract boolean	Advice.StackMapFrameHandler.Default.TranslationMode.isPossibleThisFrameValue(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.lang.Object frame)	Checks if a variable value in a stack map frame is a legal value for describing a this reference.
protected static Advice.Dispatcher.RelocationHandler	Advice.Dispatcher.RelocationHandler.ForType.of(TypeDescription typeDescription, TypeDefinition checkedType)	Resolves a relocation handler that is triggered if the checked instance is of a given type.
protected static Advice.Dispatcher.SuppressionHandler	Advice.Dispatcher.SuppressionHandler.Suppressing.of(TypeDescription suppressedType)	Resolves an appropriate suppression handler.
static Advice.OffsetMapping.Target	Advice.OffsetMapping.Target.ForStackManipulation.of(TypeDescription typeDescription)	Creates a target for an offset mapping for a type constant.
protected static Advice.StackMapFrameHandler.ForInstrumentedMethod	Advice.StackMapFrameHandler.Default.of(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean exitAdvice, boolean copyArguments, ClassFileVersion classFileVersion, int writerFlags, int readerFlags)	Creates an appropriate stack map frame handler for an instrumented method.
protected Advice.Dispatcher.Bound	Advice.Dispatcher.Delegating.Resolved.ForMethodEnter.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
protected Advice.Dispatcher.Bound	Advice.Dispatcher.Delegating.Resolved.ForMethodExit.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)
protected abstract Advice.Dispatcher.Bound	Advice.Dispatcher.Delegating.Resolved.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, StackManipulation exceptionHandler, Advice.Dispatcher.RelocationHandler.Relocation relocation)	Binds this dispatcher for resolution to a specific method.
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForAllArguments.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForArgument.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForArgument.Unresolved.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForEnterValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
protected abstract FieldDescription	Advice.OffsetMapping.ForField.resolve(TypeDescription instrumentedType)	Resolves the field being bound.
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForField.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
protected FieldDescription	Advice.OffsetMapping.ForField.Resolved.resolve(TypeDescription instrumentedType)
protected FieldDescription	Advice.OffsetMapping.ForField.Unresolved.resolve(TypeDescription instrumentedType)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForInstrumentedMethod.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForInstrumentedType.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForOrigin.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForReturnValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForSerializedValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForStackManipulation.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForStubValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForThisReference.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForThrowable.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.ForUnusedValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)
Advice.OffsetMapping.Target	Advice.OffsetMapping.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Advice.ArgumentHandler argumentHandler, Advice.OffsetMapping.Sort sort)	Resolves an offset mapping to a given target offset.
TypePool	MemberSubstitution.TypePoolResolver.ForClassFileLocator.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool)
TypePool	MemberSubstitution.TypePoolResolver.ForExplicitPool.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool)
TypePool	MemberSubstitution.TypePoolResolver.OfImplicitPool.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool)
TypePool	MemberSubstitution.TypePoolResolver.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool)	Resolves a type pool to use for locating substituted members.
static Advice	Advice.to(TypeDescription advice)	Implements advice where every matched method is advised by the given type's advisory methods.
static Advice	Advice.to(TypeDescription enterAdvice, TypeDescription exitAdvice)	Implements advice where every matched method is advised by the given type's advisory methods.
static Advice	Advice.to(TypeDescription enterAdvice, TypeDescription exitAdvice, ClassFileLocator classFileLocator)	Implements advice where every matched method is advised by the given type's advisory methods.
protected static Advice	Advice.to(TypeDescription enterAdvice, TypeDescription exitAdvice, ClassFileLocator classFileLocator, java.util.List<? extends Advice.OffsetMapping.Factory<?>> userFactories)	Creates a new advice.
static Advice	Advice.to(TypeDescription advice, ClassFileLocator classFileLocator)	Implements advice where every matched method is advised by the given type's advisory methods.
protected static Advice	Advice.to(TypeDescription advice, ClassFileLocator classFileLocator, java.util.List<? extends Advice.OffsetMapping.Factory<?>> userFactories)	Creates a new advice.
Advice	Advice.WithCustomMapping.to(TypeDescription enterAdvice, TypeDescription exitAdvice)	Implements advice where every matched method is advised by the given type's advisory methods.
Advice	Advice.WithCustomMapping.to(TypeDescription enterAdvice, TypeDescription exitAdvice, ClassFileLocator classFileLocator)	Implements advice where every matched method is advised by the given type's advisory methods.
Advice	Advice.WithCustomMapping.to(TypeDescription advice, ClassFileLocator classFileLocator)	Implements advice where every matched method is advised by the given type's advisory methods.
protected static java.lang.Object	Advice.StackMapFrameHandler.Default.toFrame(TypeDescription typeDescription)	Translates a type into a representation of its form inside a stack map frame.
org.objectweb.asm.MethodVisitor	Advice.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags)
org.objectweb.asm.ClassVisitor	AsmVisitorWrapper.Compound.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)
org.objectweb.asm.FieldVisitor	AsmVisitorWrapper.ForDeclaredFields.Entry.wrap(TypeDescription instrumentedType, FieldDescription.InDefinedShape fieldDescription, org.objectweb.asm.FieldVisitor fieldVisitor)
org.objectweb.asm.FieldVisitor	AsmVisitorWrapper.ForDeclaredFields.FieldVisitorWrapper.wrap(TypeDescription instrumentedType, FieldDescription.InDefinedShape fieldDescription, org.objectweb.asm.FieldVisitor fieldVisitor)	Wraps a field visitor.
org.objectweb.asm.ClassVisitor	AsmVisitorWrapper.ForDeclaredFields.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)
org.objectweb.asm.MethodVisitor	AsmVisitorWrapper.ForDeclaredMethods.Entry.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags)
org.objectweb.asm.MethodVisitor	AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags)	Wraps a method visitor.
org.objectweb.asm.ClassVisitor	AsmVisitorWrapper.ForDeclaredMethods.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)
org.objectweb.asm.ClassVisitor	AsmVisitorWrapper.NoOp.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)
org.objectweb.asm.ClassVisitor	AsmVisitorWrapper.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)	Applies a ClassVisitorWrapper to the creation of a DynamicType.
org.objectweb.asm.ClassVisitor	MemberRemoval.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)
org.objectweb.asm.MethodVisitor	MemberSubstitution.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags)
ModifierAdjustment.ModifierAdjustingClassVisitor	ModifierAdjustment.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)
org.objectweb.asm.ClassVisitor	TypeConstantAdjustment.wrap(TypeDescription instrumentedType, org.objectweb.asm.ClassVisitor classVisitor, Implementation.Context implementationContext, TypePool typePool, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, int writerFlags, int readerFlags)

Method parameters in net.bytebuddy.asm with type arguments of type TypeDescription

Modifier and Type	Method	Description
protected void	Advice.StackMapFrameHandler.Default.injectFullFrame(org.objectweb.asm.MethodVisitor methodVisitor, java.util.List<? extends TypeDescription> typesInArray, java.util.List<? extends TypeDescription> typesOnStack)	Injects a full stack map frame after the instrumented method has completed.
protected static Advice.MethodSizeHandler.ForInstrumentedMethod	Advice.MethodSizeHandler.Default.of(MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean copyArguments, int writerFlags)	Creates a method size handler applicable for the given instrumented method.
protected static Advice.StackMapFrameHandler.ForInstrumentedMethod	Advice.StackMapFrameHandler.Default.of(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean exitAdvice, boolean copyArguments, ClassFileVersion classFileVersion, int writerFlags, int readerFlags)	Creates an appropriate stack map frame handler for an instrumented method.
protected void	Advice.StackMapFrameHandler.Default.translateFrame(org.objectweb.asm.MethodVisitor methodVisitor, Advice.StackMapFrameHandler.Default.TranslationMode translationMode, MethodDescription methodDescription, java.util.List<? extends TypeDescription> additionalTypes, int type, int localVariableLength, java.lang.Object[] localVariable, int stackSize, java.lang.Object[] stack)	Translates a frame.
ModifierAdjustment	ModifierAdjustment.withTypeModifiers(ElementMatcher<? super TypeDescription> matcher, java.util.List<? extends ModifierContributor.ForType> modifierContributors)	Adjusts an instrumented type's modifiers if it matches the supplied matcher.
ModifierAdjustment	ModifierAdjustment.withTypeModifiers(ElementMatcher<? super TypeDescription> matcher, ModifierContributor.ForType... modifierContributor)	Adjusts an instrumented type's modifiers if it matches the supplied matcher.

Constructors in net.bytebuddy.asm with parameters of type TypeDescription

Constructor	Description
AbstractBase(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends Advice.OffsetMapping.Factory<?>> factories, TypeDescription throwableType, TypeDescription relocatableType, Advice.OffsetMapping.Factory.AdviceType adviceType)	Creates a new resolved version of a dispatcher.
AdviceMethodInliner(TypeDescription instrumentedType, MethodDescription instrumentedMethod, org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, Advice.ArgumentHandler.ForInstrumentedMethod argumentHandler, Advice.MethodSizeHandler.ForInstrumentedMethod methodSizeHandler, Advice.StackMapFrameHandler.ForInstrumentedMethod stackMapFrameHandler, Advice.Dispatcher.SuppressionHandler.Bound suppressionHandler, Advice.Dispatcher.RelocationHandler.Bound relocationHandler, org.objectweb.asm.ClassReader classReader)	Creates a new advice method inliner.
AdviceVisitor(org.objectweb.asm.MethodVisitor methodVisitor, org.objectweb.asm.MethodVisitor delegate, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, java.util.List<? extends TypeDescription> exitTypes, int writerFlags, int readerFlags)	Creates a new advice visitor.
Bound(TypeDescription typeDescription, MethodDescription instrumentedMethod, Advice.Dispatcher.RelocationHandler.Relocation relocation)	Creates a new bound relocation handler.
Bound(TypeDescription suppressedType, StackManipulation exceptionHandler)	Creates a new active, bound suppression handler.
Default(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new default stack map frame handler.
DispatchingVisitor(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, java.util.Map<java.lang.String,FieldDescription.InDefinedShape> fields)	Creates a new dispatching visitor.
DispatchingVisitor(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, Implementation.Context implementationContext, TypePool typePool, java.util.Map<java.lang.String,MethodDescription> methods, int writerFlags, int readerFlags)	Creates a new dispatching visitor.
Factory(java.lang.Class<T> annotationType, TypeDescription typeDescription, StackManipulation deserialization)	Creates a factory for loading a deserialized value.
Factory(java.lang.Class<T> annotationType, TypeDescription typeDescription)	Creates a new factory for binding a type description.
ForSerializedValue(TypeDescription.Generic target, TypeDescription typeDescription, StackManipulation deserialization)	Creates a new offset mapping for a serialized value.
ForType(TypeDescription typeDescription)	Creates a new relocation handler that triggers a relocation if a value is an instance of a given type.
ModifierAdjustingClassVisitor(org.objectweb.asm.ClassVisitor classVisitor, java.util.List<ModifierAdjustment.Adjustment<TypeDescription>> typeAdjustments, java.util.List<ModifierAdjustment.Adjustment<FieldDescription.InDefinedShape>> fieldAdjustments, java.util.List<ModifierAdjustment.Adjustment<MethodDescription>> methodAdjustments, TypeDescription instrumentedType, java.util.Map<java.lang.String,FieldDescription.InDefinedShape> fields, java.util.Map<java.lang.String,MethodDescription> methods)	Creates a new modifier adjusting visitor.
RequiringConsistentShape(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new stack map frame handler that expects the original frames to be preserved.
Resolved(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends Advice.OffsetMapping.Factory<?>> factories, TypeDescription throwableType, TypeDescription relocatableType)	Creates a new resolved version of a dispatcher.
Resolved(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends Advice.OffsetMapping.Factory<?>> factories, TypeDescription throwableType, TypeDescription relocatableType, org.objectweb.asm.ClassReader classReader)	Creates a new resolved version of a dispatcher.
SubstitutingMethodVisitor(org.objectweb.asm.MethodVisitor methodVisitor, MethodGraph.Compiler methodGraphCompiler, boolean strict, MemberSubstitution.Substitution substitution, TypeDescription instrumentedType, Implementation.Context implementationContext, TypePool typePool)	Creates a new substituting method visitor.
Suppressing(TypeDescription suppressedType)	Creates a new suppressing suppression handler.
Trivial(TypeDescription instrumentedType, MethodDescription instrumentedMethod, boolean expandFrames)	Creates a new stack map frame handler that applies a trivial translation for the instrumented method's stack map frames.
UsingArgumentCopy(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new stack map frame handler that expects an argument copy.
WithExceptionHandler(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends Advice.OffsetMapping.Factory<?>> userFactories, TypeDefinition enterType, TypeDescription throwable)	Creates a new resolved dispatcher for implementing method exit advice that handles exceptions.
WithExceptionHandler(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends Advice.OffsetMapping.Factory<?>> userFactories, org.objectweb.asm.ClassReader classReader, TypeDefinition enterType, TypeDescription throwable)	Creates a new resolved dispatcher for implementing method exit advice that handles exceptions.
WithExceptionHandling(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, int writerFlags, int readerFlags, TypeDescription throwable)	Creates a new advice visitor that captures exception by weaving try-catch blocks around user code.
WithExitAdvice(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, java.util.List<? extends TypeDescription> exitTypes, int writerFlags, int readerFlags)	Creates an advice visitor that applies exit advice.
WithExplicitType(TypeDescription.Generic target, boolean readOnly, Assigner.Typing typing, java.lang.String name, TypeDescription declaringType)	Creates an offset mapping for a field with an explicit declaring type.
WithExplicitType(TypeDescription.Generic target, AnnotationDescription.Loadable<Advice.FieldValue> annotation, TypeDescription declaringType)	Creates an offset mapping for a field with an explicit declaring type.
WithoutExceptionHandling(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, int writerFlags, int readerFlags)	Creates a new advice visitor that does not capture exceptions.
WithoutExitAdvice(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, int writerFlags, int readerFlags)	Creates an advice visitor that does not apply exit advice.
WithPreservedArguments(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new stack map frame handler that requires the stack map frames of the original arguments to be preserved.

Constructor parameters in net.bytebuddy.asm with type arguments of type TypeDescription

Constructor	Description
AdviceVisitor(org.objectweb.asm.MethodVisitor methodVisitor, org.objectweb.asm.MethodVisitor delegate, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, java.util.List<? extends TypeDescription> exitTypes, int writerFlags, int readerFlags)	Creates a new advice visitor.
Default(MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes)	Creates a new default meta data handler that recomputes the space requirements of an instrumented method.
Default(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new default stack map frame handler.
ForAdvice(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends TypeDescription> startTypes, java.util.List<? extends TypeDescription> endTypes)	Creates a new method size handler for an advice method.
ForAdvice(MethodDescription.InDefinedShape adviceMethod, java.util.List<? extends TypeDescription> startTypes, java.util.List<? extends TypeDescription> endTypes, Advice.StackMapFrameHandler.Default.TranslationMode translationMode)	Creates a new meta data handler for an advice method.
ModifierAdjustingClassVisitor(org.objectweb.asm.ClassVisitor classVisitor, java.util.List<ModifierAdjustment.Adjustment<TypeDescription>> typeAdjustments, java.util.List<ModifierAdjustment.Adjustment<FieldDescription.InDefinedShape>> fieldAdjustments, java.util.List<ModifierAdjustment.Adjustment<MethodDescription>> methodAdjustments, TypeDescription instrumentedType, java.util.Map<java.lang.String,FieldDescription.InDefinedShape> fields, java.util.Map<java.lang.String,MethodDescription> methods)	Creates a new modifier adjusting visitor.
ModifierAdjustment(java.util.List<ModifierAdjustment.Adjustment<TypeDescription>> typeAdjustments, java.util.List<ModifierAdjustment.Adjustment<FieldDescription.InDefinedShape>> fieldAdjustments, java.util.List<ModifierAdjustment.Adjustment<MethodDescription>> methodAdjustments)	Creates a new modifier adjustment.
RequiringConsistentShape(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new stack map frame handler that expects the original frames to be preserved.
UsingArgumentCopy(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new stack map frame handler that expects an argument copy.
WithCopiedArguments(MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes)	Creates a new default method size handler that expectes the original arguments to be copied.
WithExitAdvice(org.objectweb.asm.MethodVisitor methodVisitor, Implementation.Context implementationContext, Assigner assigner, StackManipulation exceptionHandler, TypeDescription instrumentedType, MethodDescription instrumentedMethod, Advice.Dispatcher.Resolved.ForMethodEnter methodEnter, Advice.Dispatcher.Resolved.ForMethodExit methodExit, java.util.List<? extends TypeDescription> exitTypes, int writerFlags, int readerFlags)	Creates an advice visitor that applies exit advice.
WithPreservedArguments(TypeDescription instrumentedType, MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes, boolean expandFrames)	Creates a new stack map frame handler that requires the stack map frames of the original arguments to be preserved.
WithRetainedArguments(MethodDescription instrumentedMethod, java.util.List<? extends TypeDescription> enterTypes, java.util.List<? extends TypeDescription> exitTypes)	Creates a new default method size handler that expects that the original arguments are retained.

Uses of TypeDescription in net.bytebuddy.build

Methods in net.bytebuddy.build with parameters of type TypeDescription

Modifier and Type	Method	Description
DynamicType.Builder<?>	HashCodeAndEqualsPlugin.apply(DynamicType.Builder<?> builder, TypeDescription typeDescription)
DynamicType.Builder<?>	Plugin.apply(DynamicType.Builder<?> builder, TypeDescription typeDescription)	Applies this plugin.
DynamicType.Builder<?>	ToStringPlugin.apply(DynamicType.Builder<?> builder, TypeDescription typeDescription)
protected abstract EqualsMethod	HashCodeAndEqualsPlugin.Enhance.InvokeSuper.equalsMethod(TypeDescription instrumentedType)	Resolves the equals method to use.
protected abstract HashCodeMethod	HashCodeAndEqualsPlugin.Enhance.InvokeSuper.hashCodeMethod(TypeDescription instrumentedType)	Resolves the hash code method to use.
boolean	HashCodeAndEqualsPlugin.matches(TypeDescription target)
boolean	ToStringPlugin.matches(TypeDescription target)
DynamicType.Builder<?>	EntryPoint.transform(TypeDescription typeDescription, ByteBuddy byteBuddy, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer)	Applies a transformation.

Uses of TypeDescription in net.bytebuddy.description

Methods in net.bytebuddy.description with parameters of type TypeDescription

Modifier and Type	Method	Description
boolean	ByteCodeElement.isAccessibleTo(TypeDescription typeDescription)	Checks if this element is accessible from a given type.
boolean	ByteCodeElement.isVisibleTo(TypeDescription typeDescription)	Checks if this element is visible from a given type.
TypeVariableSource	TypeVariableSource.Visitor.NoOp.onType(TypeDescription typeDescription)
T	TypeVariableSource.Visitor.onType(TypeDescription typeDescription)	Applies the visitor on a type.

Method parameters in net.bytebuddy.description with type arguments of type TypeDescription

Modifier and Type	Method	Description
S	ByteCodeElement.TypeDependant.asToken(ElementMatcher<? super TypeDescription> matcher)	Returns a token representative of this type dependant.

Uses of TypeDescription in net.bytebuddy.description.annotation

Methods in net.bytebuddy.description.annotation that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	AnnotationDescription.ForLoadedAnnotation.getAnnotationType()
TypeDescription	AnnotationDescription.getAnnotationType()	Returns a description of the annotation type of this annotation.
TypeDescription	AnnotationDescription.Latent.getAnnotationType()
TypeDescription	AnnotationDescription.Latent.Loadable.getAnnotationType()
TypeDescription	AnnotationValue.ForTypeDescription.resolve()

Methods in net.bytebuddy.description.annotation that return types with arguments of type TypeDescription

Modifier and Type	Method	Description
static <V extends java.lang.Class<V>> AnnotationValue<TypeDescription,V>	AnnotationValue.ForTypeDescription.of(TypeDescription typeDescription)	Creates an annotation value for representing the given type.

Methods in net.bytebuddy.description.annotation with parameters of type TypeDescription

Modifier and Type	Method	Description
AnnotationDescription.Builder	AnnotationDescription.Builder.define(java.lang.String property, TypeDescription typeDescription)	Returns a builder with the additional class property.
AnnotationDescription.Builder	AnnotationDescription.Builder.define(java.lang.String property, TypeDescription enumerationType, java.lang.String value)	Returns a builder with the additional enumeration property.
AnnotationDescription.Builder	AnnotationDescription.Builder.defineAnnotationArray(java.lang.String property, TypeDescription annotationType, AnnotationDescription... annotationDescription)	Returns a builder with the additional annotation array property.
AnnotationDescription.Builder	AnnotationDescription.Builder.defineEnumerationArray(java.lang.String property, TypeDescription enumerationType, java.lang.String... value)	Returns a builder with the additional enumeration array property.
AnnotationDescription.Builder	AnnotationDescription.Builder.defineEnumerationArray(java.lang.String property, TypeDescription enumerationType, EnumerationDescription... value)	Returns a builder with the additional enumeration array property.
AnnotationDescription.Builder	AnnotationDescription.Builder.defineTypeArray(java.lang.String property, TypeDescription... typeDescription)	Returns a builder with the additional type array property.
boolean	AnnotationList.AbstractBase.isAnnotationPresent(TypeDescription annotationType)
boolean	AnnotationList.Empty.isAnnotationPresent(TypeDescription annotationType)
boolean	AnnotationList.isAnnotationPresent(TypeDescription annotationType)	Checks if this list contains an annotation of the given type.
static <V extends java.lang.annotation.Annotation> AnnotationValue<AnnotationDescription,V>	AnnotationValue.ForAnnotationDescription.of(TypeDescription annotationType, java.util.Map<java.lang.String,? extends AnnotationValue<?,?>> annotationValues)	Creates an annotation value instance for describing the given annotation type and values.
static AnnotationValue<TypeDescription[],java.lang.Class<?>[]>	AnnotationValue.ForDescriptionArray.of(TypeDescription[] typeDescription)	Creates a new complex array of annotation descriptions.
static <W extends java.lang.annotation.Annotation> AnnotationValue<AnnotationDescription[],W[]>	AnnotationValue.ForDescriptionArray.of(TypeDescription annotationType, AnnotationDescription[] annotationDescription)	Creates a new complex array of annotation descriptions.
static <W extends java.lang.Enum<W>> AnnotationValue<EnumerationDescription[],W[]>	AnnotationValue.ForDescriptionArray.of(TypeDescription enumerationType, EnumerationDescription[] enumerationDescription)	Creates a new complex array of enumeration descriptions.
static <V extends java.lang.Class<V>> AnnotationValue<TypeDescription,V>	AnnotationValue.ForTypeDescription.of(TypeDescription typeDescription)	Creates an annotation value for representing the given type.
static AnnotationDescription.Builder	AnnotationDescription.Builder.ofType(TypeDescription annotationType)	Creates a builder for creating an annotation of the given type.
AnnotationDescription	AnnotationList.AbstractBase.ofType(TypeDescription annotationType)
AnnotationDescription	AnnotationList.Empty.ofType(TypeDescription annotationType)
AnnotationDescription	AnnotationList.ofType(TypeDescription annotationType)	Finds the first annotation of the given type and returns it.
abstract java.lang.String	AnnotationValue.RenderingDispatcher.toSourceString(TypeDescription value)	Represents the supplied TypeDescription value as a String.

Method parameters in net.bytebuddy.description.annotation with type arguments of type TypeDescription

Modifier and Type	Method	Description
AnnotationList	AnnotationList.AbstractBase.inherited(java.util.Set<? extends TypeDescription> ignoredTypes)
AnnotationList	AnnotationList.Empty.inherited(java.util.Set<? extends TypeDescription> ignoredTypes)
AnnotationList	AnnotationList.inherited(java.util.Set<? extends TypeDescription> ignoredTypes)	Returns only annotations that are marked as Inherited as long as they are not contained by the set of ignored annotation types.

Constructors in net.bytebuddy.description.annotation with parameters of type TypeDescription

Constructor	Description
Builder(TypeDescription annotationType, java.util.Map<java.lang.String,AnnotationValue<?,?>> annotationValues)	Creates a builder for an annotation description.
ForDescriptionArray(java.lang.Class<?> unloadedComponentType, TypeDescription componentType, java.util.List<? extends AnnotationValue<?,?>> values)	Creates a new complex array.
ForTypeDescription(TypeDescription typeDescription)	Creates a new annotation value that represents a type.
Latent(TypeDescription annotationType, java.util.Map<java.lang.String,? extends AnnotationValue<?,?>> annotationValues)	Creates a new latent annotation description.

Uses of TypeDescription in net.bytebuddy.description.enumeration

Methods in net.bytebuddy.description.enumeration that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	EnumerationDescription.ForLoadedEnumeration.getEnumerationType()
TypeDescription	EnumerationDescription.getEnumerationType()	Returns the type of this enumeration.
TypeDescription	EnumerationDescription.Latent.getEnumerationType()

Constructors in net.bytebuddy.description.enumeration with parameters of type TypeDescription

Constructor	Description
Latent(TypeDescription enumerationType, java.lang.String value)	Creates a latent description of an enumeration value.

Uses of TypeDescription in net.bytebuddy.description.field

Methods in net.bytebuddy.description.field that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	FieldDescription.ForLoadedField.getDeclaringType()
TypeDescription	FieldDescription.InDefinedShape.getDeclaringType()
TypeDescription	FieldDescription.Latent.getDeclaringType()
TypeDescription	FieldDescription.SignatureToken.getType()	Returns the type of the represented field.

Methods in net.bytebuddy.description.field with parameters of type TypeDescription

Modifier and Type	Method	Description
FieldDescription.SignatureToken	FieldDescription.Token.asSignatureToken(TypeDescription declaringType)	Creates a signature token that represents the method that is represented by this token.
boolean	FieldDescription.AbstractBase.isAccessibleTo(TypeDescription typeDescription)
boolean	FieldDescription.AbstractBase.isVisibleTo(TypeDescription typeDescription)

Method parameters in net.bytebuddy.description.field with type arguments of type TypeDescription

Modifier and Type	Method	Description
FieldDescription.Token	FieldDescription.AbstractBase.asToken(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<FieldDescription.Token>	FieldList.AbstractBase.asTokenList(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<FieldDescription.Token>	FieldList.asTokenList(ElementMatcher<? super TypeDescription> matcher)	Transforms the list of field descriptions into a list of detached tokens.
ByteCodeElement.Token.TokenList<FieldDescription.Token>	FieldList.Empty.asTokenList(ElementMatcher<? super TypeDescription> matcher)

Constructors in net.bytebuddy.description.field with parameters of type TypeDescription

Constructor	Description
ForTokens(TypeDescription declaringType, java.util.List<? extends FieldDescription.Token> tokens)	Creates a new field list from a list of field tokens.
ForTokens(TypeDescription declaringType, FieldDescription.Token... token)	Creates a new field list from a list of field tokens.
Latent(TypeDescription declaringType, java.lang.String fieldName, int modifiers, TypeDescription.Generic fieldType, java.util.List<? extends AnnotationDescription> declaredAnnotations)	Creates a new latent field description.
Latent(TypeDescription declaringType, FieldDescription.Token token)	Creates a new latent field description.
SignatureToken(java.lang.String name, TypeDescription type)	Creates a new signature token.

Uses of TypeDescription in net.bytebuddy.description.method

Methods in net.bytebuddy.description.method that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	MethodDescription.ForLoadedConstructor.getDeclaringType()
TypeDescription	MethodDescription.ForLoadedMethod.getDeclaringType()
TypeDescription	MethodDescription.InDefinedShape.getDeclaringType()
TypeDescription	MethodDescription.Latent.getDeclaringType()
TypeDescription	MethodDescription.Latent.TypeInitializer.getDeclaringType()
TypeDescription	MethodDescription.SignatureToken.getReturnType()	Returns this token's return type.
TypeDescription	MethodDescription.TypeToken.getReturnType()	Returns this token's return type.

Methods in net.bytebuddy.description.method that return types with arguments of type TypeDescription

Modifier and Type	Method	Description
java.util.List<TypeDescription>	MethodDescription.SignatureToken.getParameterTypes()	Returns this token's parameter types.
java.util.List<TypeDescription>	MethodDescription.TypeToken.getParameterTypes()	Returns this token's parameter types.

Methods in net.bytebuddy.description.method with parameters of type TypeDescription

Modifier and Type	Method	Description
MethodDescription.SignatureToken	MethodDescription.Token.asSignatureToken(TypeDescription declaringType)	Creates a signature token that represents the method that is represented by this token.
boolean	MethodDescription.AbstractBase.isAccessibleTo(TypeDescription typeDescription)
boolean	MethodDescription.AbstractBase.isInvokableOn(TypeDescription typeDescription)
boolean	MethodDescription.isInvokableOn(TypeDescription typeDescription)	Asserts if this method is invokable on an instance of the given type, i.e.
boolean	MethodDescription.AbstractBase.isSpecializableFor(TypeDescription targetType)
boolean	MethodDescription.isSpecializableFor(TypeDescription typeDescription)	Checks if this method can be called using the INVOKESPECIAL for a given type.
boolean	MethodDescription.AbstractBase.isVisibleTo(TypeDescription typeDescription)

Method parameters in net.bytebuddy.description.method with type arguments of type TypeDescription

Modifier and Type	Method	Description
MethodDescription.Token	MethodDescription.AbstractBase.asToken(ElementMatcher<? super TypeDescription> matcher)
ParameterDescription.Token	ParameterDescription.AbstractBase.asToken(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<MethodDescription.Token>	MethodList.AbstractBase.asTokenList(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<MethodDescription.Token>	MethodList.asTokenList(ElementMatcher<? super TypeDescription> matcher)	Transforms the list of method descriptions into a list of detached tokens.
ByteCodeElement.Token.TokenList<MethodDescription.Token>	MethodList.Empty.asTokenList(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<ParameterDescription.Token>	ParameterList.AbstractBase.asTokenList(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<ParameterDescription.Token>	ParameterList.asTokenList(ElementMatcher<? super TypeDescription> matcher)	Transforms the list of parameter descriptions into a list of detached tokens.
ByteCodeElement.Token.TokenList<ParameterDescription.Token>	ParameterList.Empty.asTokenList(ElementMatcher<? super TypeDescription> matcher)

Constructors in net.bytebuddy.description.method with parameters of type TypeDescription

Constructor	Description
ForTokens(TypeDescription declaringType, java.util.List<? extends MethodDescription.Token> tokens)	Creates a new list of method descriptions for a list of detached tokens.
ForTokens(TypeDescription declaringType, MethodDescription.Token... token)	Creates a new list of method descriptions for a list of detached tokens.
Latent(TypeDescription declaringType, java.lang.String internalName, int modifiers, java.util.List<? extends TypeVariableToken> typeVariables, TypeDescription.Generic returnType, java.util.List<? extends ParameterDescription.Token> parameterTokens, java.util.List<? extends TypeDescription.Generic> exceptionTypes, java.util.List<? extends AnnotationDescription> declaredAnnotations, AnnotationValue<?,?> defaultValue, TypeDescription.Generic receiverType)	Creates a new latent method description.
Latent(TypeDescription declaringType, MethodDescription.Token token)	Creates a new latent method description.
SignatureToken(java.lang.String name, TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a new type token.
TypeInitializer(TypeDescription typeDescription)	Creates a new method description representing the type initializer.
TypeToken(TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a new type token.

Constructor parameters in net.bytebuddy.description.method with type arguments of type TypeDescription

Constructor	Description
SignatureToken(java.lang.String name, TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a new type token.
TypeToken(TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a new type token.

Uses of TypeDescription in net.bytebuddy.description.type

Classes in net.bytebuddy.description.type that implement TypeDescription

Modifier and Type	Class	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.

Fields in net.bytebuddy.description.type declared as TypeDescription

Modifier and Type	Field	Description
static TypeDescription	TypeDescription.CLASS	A representation of the Class type.
static TypeDescription	TypeDescription.OBJECT	A representation of the Object type.
static TypeDescription	TypeDescription.STRING	A representation of the String type.
static TypeDescription	TypeDescription.THROWABLE	A representation of the Throwable type.
static TypeDescription	TypeDescription.UNDEFINED	Represents any undefined property representing a type description that is instead represented as null in order to resemble the Java reflection API which returns null and is intuitive to many Java developers.
static TypeDescription	TypeDescription.VOID	A representation of the void non-type.

Methods in net.bytebuddy.description.type that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	TypeDescription.AbstractBase.asBoxed()
TypeDescription	TypeDescription.asBoxed()	Returns a description of this type that represents this type as a boxed type for primitive types, unless its void.
TypeDescription	TypeDefinition.asErasure()	Returns the erasure of this type.
TypeDescription	TypeDescription.AbstractBase.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.ForLoadedFieldType.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.ForLoadedReturnType.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.ForLoadedSuperClass.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.OfConstructorParameter.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.OfMethodParameter.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazyInterfaceType.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.WithLazyNavigation.LazySuperClass.asErasure()
TypeDescription	TypeDescription.Generic.LazyProjection.WithResolvedErasure.asErasure()
TypeDescription	TypeDescription.Generic.OfGenericArray.asErasure()
TypeDescription	TypeDescription.Generic.OfNonGenericType.ForErasure.asErasure()
TypeDescription	TypeDescription.Generic.OfNonGenericType.ForLoadedType.asErasure()
TypeDescription	TypeDescription.Generic.OfNonGenericType.ForReifiedErasure.asErasure()
TypeDescription	TypeDescription.Generic.OfNonGenericType.Latent.asErasure()
TypeDescription	TypeDescription.Generic.OfParameterizedType.ForGenerifiedErasure.asErasure()
TypeDescription	TypeDescription.Generic.OfParameterizedType.ForLoadedType.asErasure()
TypeDescription	TypeDescription.Generic.OfParameterizedType.ForReifiedType.asErasure()
TypeDescription	TypeDescription.Generic.OfParameterizedType.Latent.asErasure()
TypeDescription	TypeDescription.Generic.OfTypeVariable.asErasure()
TypeDescription	TypeDescription.Generic.OfTypeVariable.Symbolic.asErasure()
TypeDescription	TypeDescription.Generic.OfWildcardType.asErasure()
TypeDescription	TypeDescription.SuperTypeLoading.ClassLoadingTypeProjection.asErasure()
TypeDescription	TypeDescription.AbstractBase.asUnboxed()
TypeDescription	TypeDescription.asUnboxed()	Returns a description of this type that represents this type as an unboxed type for boxing types, unless its Void.
protected abstract TypeDescription	TypeDescription.AbstractBase.OfSimpleType.WithDelegation.delegate()	Returns the delegate type description to this type instance.
TypeDescription	TypeList.Explicit.get(int index)
TypeDescription	TypeList.ForLoadedTypes.get(int index)
TypeDescription	TypeDescription.AbstractBase.OfSimpleType.getComponentType()
TypeDescription	TypeDescription.ArrayProjection.getComponentType()
TypeDescription	TypeDescription.ForLoadedType.getComponentType()
TypeDescription	TypeDescription.getComponentType()
TypeDescription	TypeDescription.SuperTypeLoading.getComponentType()
TypeDescription	TypeDescription.AbstractBase.OfSimpleType.WithDelegation.getDeclaringType()
TypeDescription	TypeDescription.ArrayProjection.getDeclaringType()
TypeDescription	TypeDescription.ForLoadedType.getDeclaringType()
TypeDescription	TypeDescription.ForPackageDescription.getDeclaringType()
TypeDescription	TypeDescription.getDeclaringType()
TypeDescription	TypeDescription.Latent.getDeclaringType()
TypeDescription	TypeDescription.SuperTypeLoading.getDeclaringType()
TypeDescription	TypeDescription.AbstractBase.OfSimpleType.WithDelegation.getEnclosingType()
TypeDescription	TypeDescription.ArrayProjection.getEnclosingType()
TypeDescription	TypeDescription.ForLoadedType.getEnclosingType()
TypeDescription	TypeDescription.ForPackageDescription.getEnclosingType()
TypeDescription	TypeDescription.getEnclosingType()	Returns a description of this type's enclosing type if any.
TypeDescription	TypeDescription.Latent.getEnclosingType()
TypeDescription	TypeDescription.SuperTypeLoading.getEnclosingType()
static TypeDescription	TypeDescription.ArrayProjection.of(TypeDescription componentType)	Creates an array projection of an arity of one.
static TypeDescription	TypeDescription.ArrayProjection.of(TypeDescription componentType, int arity)	Creates an array projection.
TypeDescription	TypeDescription.Generic.Visitor.Reducing.onGenericArray(TypeDescription.Generic genericArray)
TypeDescription	TypeDescription.Generic.Visitor.Reducing.onNonGenericType(TypeDescription.Generic typeDescription)
TypeDescription	TypeDescription.Generic.Visitor.Reducing.onParameterizedType(TypeDescription.Generic parameterizedType)
TypeDescription	TypeDescription.Generic.Visitor.Reducing.onTypeVariable(TypeDescription.Generic typeVariable)
TypeDescription	TypeDescription.Generic.Visitor.Reducing.onWildcard(TypeDescription.Generic wildcard)

Methods in net.bytebuddy.description.type with parameters of type TypeDescription

Modifier and Type	Method	Description
protected abstract void	TypeDescription.Generic.OfParameterizedType.RenderingDelegate.apply(java.lang.StringBuilder stringBuilder, TypeDescription typeDescription, TypeDescription.Generic ownerType)	Applies this rendering delegate.
static TypeList.Generic	TypeList.Generic.ForDetachedTypes.attachVariables(TypeDescription typeDescription, java.util.List<? extends TypeVariableToken> detachedTypeVariables)	Creates a list of type variables that are attached to the provided type.
boolean	PackageDescription.AbstractBase.contains(TypeDescription typeDescription)
boolean	PackageDescription.contains(TypeDescription typeDescription)	Checks if this package contains the provided type.
boolean	TypeDescription.AbstractBase.isAccessibleTo(TypeDescription typeDescription)
boolean	TypeDescription.AbstractBase.isAssignableFrom(TypeDescription typeDescription)
boolean	TypeDescription.isAssignableFrom(TypeDescription typeDescription)	Checks if this type is assignable from the type described by this instance, for example for class Foo and class Bar extends Foo, this method would return true for Foo.class.isAssignableFrom(Bar.class).
boolean	TypeDescription.AbstractBase.isAssignableTo(TypeDescription typeDescription)
boolean	TypeDescription.isAssignableTo(TypeDescription typeDescription)	Checks if this type is assignable from the type described by this instance, for example for class Foo and class Bar extends Foo, this method would return true for Bar.class.isAssignableFrom(Foo.class).
boolean	TypeDescription.AbstractBase.isSamePackage(TypeDescription typeDescription)
boolean	TypeDescription.isSamePackage(TypeDescription typeDescription)	Checks if two types are defined in the same package.
boolean	TypeDescription.AbstractBase.isVisibleTo(TypeDescription typeDescription)
static TypeDescription	TypeDescription.ArrayProjection.of(TypeDescription componentType)	Creates an array projection of an arity of one.
static TypeDescription	TypeDescription.ArrayProjection.of(TypeDescription componentType, int arity)	Creates an array projection.
protected static TypeDescription.Generic	TypeDescription.Generic.OfNonGenericType.ForReifiedErasure.of(TypeDescription typeDescription)	Creates a new generic type representation for an erasure where any generified type is reified.
static TypeDescription.Generic	TypeDescription.Generic.OfParameterizedType.ForGenerifiedErasure.of(TypeDescription typeDescription)	Represents the supplied type description as a generified erasure if it is generified or as a non-generic type if not so.
static TypeDescription.Generic.Visitor.Substitutor.ForAttachment	TypeDescription.Generic.Visitor.Substitutor.ForAttachment.of(TypeDescription typeDescription)	Attaches all types to the given type description.
TypeDescription.Generic	TypeDescription.Generic.Visitor.Substitutor.ForTypeVariableBinding.TypeVariableSubstitutor.onType(TypeDescription typeDescription)
static TypeDescription.Generic.Builder	TypeDescription.Generic.Builder.parameterizedType(TypeDescription rawType, java.util.Collection<? extends TypeDefinition> parameters)	Creates a parameterized type without an owner type or with a non-generic owner type.
static TypeDescription.Generic.Builder	TypeDescription.Generic.Builder.parameterizedType(TypeDescription rawType, TypeDefinition... parameter)	Creates a parameterized type without an owner type or with a non-generic owner type.
static TypeDescription.Generic.Builder	TypeDescription.Generic.Builder.parameterizedType(TypeDescription rawType, TypeDescription.Generic ownerType, java.util.Collection<? extends TypeDefinition> parameters)	Creates a parameterized type.
static TypeDescription.Generic.Builder	TypeDescription.Generic.Builder.rawType(TypeDescription type)	Creates a raw type of a type description.
static TypeDescription.Generic.Builder	TypeDescription.Generic.Builder.rawType(TypeDescription type, TypeDescription.Generic ownerType)	Creates a raw type of a type description.

Method parameters in net.bytebuddy.description.type with type arguments of type TypeDescription

Modifier and Type	Method	Description
ByteCodeElement.Token.TokenList<TypeVariableToken>	TypeList.Generic.AbstractBase.asTokenList(ElementMatcher<? super TypeDescription> matcher)
ByteCodeElement.Token.TokenList<TypeVariableToken>	TypeList.Generic.asTokenList(ElementMatcher<? super TypeDescription> visitor)	Transforms a list of attached type variables into their tokenized form.
ByteCodeElement.Token.TokenList<TypeVariableToken>	TypeList.Generic.Empty.asTokenList(ElementMatcher<? super TypeDescription> matcher)
static TypeVariableToken	TypeVariableToken.of(TypeDescription.Generic typeVariable, ElementMatcher<? super TypeDescription> matcher)	Transforms a type variable into a type variable token with its bounds detached.
protected TypeList	TypeList.AbstractBase.wrap(java.util.List<TypeDescription> values)

Constructors in net.bytebuddy.description.type with parameters of type TypeDescription

Constructor	Description
ArrayProjection(TypeDescription componentType, int arity)	Creates a new array projection.
Explicit(TypeDescription... typeDescription)	Creates an immutable wrapper.
ForAttachment(TypeDescription declaringType, TypeVariableSource typeVariableSource)	Creates a visitor for attaching type variables.
ForErasure(TypeDescription typeDescription)	Creates a new description of a non-generic type as an erasure.
ForGenerifiedErasure(TypeDescription typeDescription)	Creates a new generified erasure.
ForNonGenericType(TypeDescription typeDescription)	Creates a new dispatcher of a non-generic type.
ForRawType(TypeDescription declaringType)	Creates a visitor for representing declared types of a potentially raw type.
ForReifiedErasure(TypeDescription typeDescription)	Creates a new reified non-generic type.
ForTokenNormalization(TypeDescription typeDescription)	Creates a new token normalization visitor.
Latent(TypeDescription typeDescription, AnnotationSource annotationSource)	Creates a non-generic type with an implicit owner type.
Latent(TypeDescription typeDescription, TypeDescription.Generic declaringType, AnnotationSource annotationSource)	Creates a non-generic type.
Latent(TypeDescription rawType, TypeDescription.Generic ownerType, java.util.List<? extends TypeDescription.Generic> parameters, AnnotationSource annotationSource)	Creates a description of a latent parameterized type.
OfNonGenericType(TypeDescription typeDescription)	Creates a builder for a non-generic type.
OfNonGenericType(TypeDescription typeDescription, TypeDescription.Generic ownerType)	Creates a builder for a non-generic type.
OfNonGenericType(TypeDescription typeDescription, TypeDescription.Generic ownerType, java.util.List<? extends AnnotationDescription> annotations)	Creates a builder for a non-generic type.
OfParameterizedType(TypeDescription rawType, TypeDescription.Generic ownerType, java.util.List<? extends TypeDescription.Generic> parameterTypes)	Creates a builder for a parameterized type.
OfParameterizedType(TypeDescription rawType, TypeDescription.Generic ownerType, java.util.List<? extends TypeDescription.Generic> parameterTypes, java.util.List<? extends AnnotationDescription> annotations)	Creates a builder for a parameterized type.
Reducing(TypeDescription declaringType)	Creates a new reducing type visitor.
Reducing(TypeDescription declaringType, java.util.List<? extends TypeVariableToken> typeVariableTokens)	Creates a new reducing type visitor.
SuperTypeLoading(TypeDescription delegate, java.lang.ClassLoader classLoader)	Creates a super type loading type description.
SuperTypeLoading(TypeDescription delegate, java.lang.ClassLoader classLoader, TypeDescription.SuperTypeLoading.ClassLoadingDelegate classLoadingDelegate)	Creates a super type loading type description.

Constructor parameters in net.bytebuddy.description.type with type arguments of type TypeDescription

Constructor	Description
Explicit(java.util.List<? extends TypeDescription> typeDescriptions)	Creates an immutable wrapper.
ForDetachment(ElementMatcher<? super TypeDescription> typeMatcher)	Creates a visitor for detaching a type.

Uses of TypeDescription in net.bytebuddy.dynamic

Fields in net.bytebuddy.dynamic declared as TypeDescription

Modifier and Type	Field	Description
static TypeDescription	TargetType.DESCRIPTION	A description of the TargetType.
protected TypeDescription	DynamicType.Default.typeDescription	A type description of this dynamic type.

Methods in net.bytebuddy.dynamic that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	DynamicType.Default.getTypeDescription()
TypeDescription	DynamicType.getTypeDescription()	Returns a description of this dynamic type.
static TypeDescription	TargetType.resolve(TypeDescription typeDescription, TypeDescription targetType)	Resolves the given type description to the supplied target type if it represents the TargetType placeholder.

Methods in net.bytebuddy.dynamic that return types with arguments of type TypeDescription

Modifier and Type	Method	Description
java.util.Map<TypeDescription,byte[]>	DynamicType.Default.getAllTypes()
java.util.Map<TypeDescription,byte[]>	DynamicType.getAllTypes()	Returns all types that are implied by this dynamic type.
java.util.Map<TypeDescription,byte[]>	DynamicType.Default.getAuxiliaryTypes()
java.util.Map<TypeDescription,byte[]>	DynamicType.getAuxiliaryTypes()	Returns a map of all auxiliary types that are required for making use of the main type.
java.util.Map<TypeDescription,java.lang.Class<?>>	DynamicType.Default.Loaded.getLoadedAuxiliaryTypes()
java.util.Map<TypeDescription,java.lang.Class<?>>	DynamicType.Loaded.getLoadedAuxiliaryTypes()	Returns a map of all loaded auxiliary types to this dynamic type.
java.util.Map<TypeDescription,LoadedTypeInitializer>	DynamicType.Default.getLoadedTypeInitializers()
java.util.Map<TypeDescription,LoadedTypeInitializer>	DynamicType.getLoadedTypeInitializers()	Returns a map of all loaded type initializers for the main type and all auxiliary types, if any.
<S extends java.lang.ClassLoader> java.util.Map<TypeDescription,java.lang.Class<?>>	TypeResolutionStrategy.Active.Resolved.initialize(DynamicType dynamicType, S classLoader, ClassLoadingStrategy<? super S> classLoadingStrategy)
<S extends java.lang.ClassLoader> java.util.Map<TypeDescription,java.lang.Class<?>>	TypeResolutionStrategy.Disabled.initialize(DynamicType dynamicType, S classLoader, ClassLoadingStrategy<? super S> classLoadingStrategy)
<S extends java.lang.ClassLoader> java.util.Map<TypeDescription,java.lang.Class<?>>	TypeResolutionStrategy.Lazy.initialize(DynamicType dynamicType, S classLoader, ClassLoadingStrategy<? super S> classLoadingStrategy)
<S extends java.lang.ClassLoader> java.util.Map<TypeDescription,java.lang.Class<?>>	TypeResolutionStrategy.Passive.initialize(DynamicType dynamicType, S classLoader, ClassLoadingStrategy<? super S> classLoadingStrategy)
<S extends java.lang.ClassLoader> java.util.Map<TypeDescription,java.lang.Class<?>>	TypeResolutionStrategy.Resolved.initialize(DynamicType dynamicType, S classLoader, ClassLoadingStrategy<? super S> classLoadingStrategy)	Loads and initializes a dynamic type.
java.util.Map<TypeDescription,java.io.File>	DynamicType.Default.saveIn(java.io.File folder)
java.util.Map<TypeDescription,java.io.File>	DynamicType.saveIn(java.io.File folder)	Saves a dynamic type in a given folder using the Java class file format while respecting the naming conventions for saving compiled Java classes.

Methods in net.bytebuddy.dynamic with parameters of type TypeDescription

Modifier and Type	Method	Description
static TypeDescription	TargetType.resolve(TypeDescription typeDescription, TypeDescription targetType)	Resolves the given type description to the supplied target type if it represents the TargetType placeholder.
S	Transformer.Compound.transform(TypeDescription instrumentedType, S target)
FieldDescription.Token	Transformer.ForField.FieldModifierTransformer.transform(TypeDescription instrumentedType, FieldDescription.Token target)
FieldDescription	Transformer.ForField.transform(TypeDescription instrumentedType, FieldDescription fieldDescription)
MethodDescription.Token	Transformer.ForMethod.MethodModifierTransformer.transform(TypeDescription instrumentedType, MethodDescription.Token target)
MethodDescription	Transformer.ForMethod.transform(TypeDescription instrumentedType, MethodDescription methodDescription)
java.lang.Object	Transformer.NoOp.transform(TypeDescription instrumentedType, java.lang.Object target)
T	Transformer.transform(TypeDescription instrumentedType, T target)	Transforms the supplied target.

Method parameters in net.bytebuddy.dynamic with type arguments of type TypeDescription

Modifier and Type	Method	Description
static ClassFileLocator	ClassFileLocator.Simple.of(java.util.Map<TypeDescription,byte[]> binaryRepresentations)	Creates a class file locator that represents all types of a dynamic type.

Constructors in net.bytebuddy.dynamic with parameters of type TypeDescription

Constructor	Description
Default(TypeDescription typeDescription, byte[] binaryRepresentation, LoadedTypeInitializer loadedTypeInitializer, java.util.List<? extends DynamicType> auxiliaryTypes)	Creates a new dynamic type.
Loaded(TypeDescription typeDescription, byte[] typeByte, LoadedTypeInitializer loadedTypeInitializer, java.util.List<? extends DynamicType> auxiliaryTypes, java.util.Map<TypeDescription,java.lang.Class<?>> loadedTypes)	Creates a new representation of a loaded dynamic type.
TransformedField(TypeDescription instrumentedType, TypeDefinition declaringType, FieldDescription.Token token, FieldDescription.InDefinedShape fieldDescription)	Creates a new transformed field.
TransformedMethod(TypeDescription instrumentedType, TypeDefinition declaringType, MethodDescription.Token token, MethodDescription.InDefinedShape methodDescription)	Creates a new transformed method.
Unloaded(TypeDescription typeDescription, byte[] binaryRepresentation, LoadedTypeInitializer loadedTypeInitializer, java.util.List<? extends DynamicType> auxiliaryTypes, TypeResolutionStrategy.Resolved typeResolutionStrategy)	Creates a new unloaded representation of a dynamic type.

Constructor parameters in net.bytebuddy.dynamic with type arguments of type TypeDescription

Constructor	Description
Loaded(TypeDescription typeDescription, byte[] typeByte, LoadedTypeInitializer loadedTypeInitializer, java.util.List<? extends DynamicType> auxiliaryTypes, java.util.Map<TypeDescription,java.lang.Class<?>> loadedTypes)	Creates a new representation of a loaded dynamic type.

Uses of TypeDescription in net.bytebuddy.dynamic.loading

Methods in net.bytebuddy.dynamic.loading that return types with arguments of type TypeDescription

Modifier and Type	Method	Description
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.inject(java.util.Map<? extends TypeDescription,byte[]> types)	Injects the given types into the represented class loader.
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingInstrumentation.inject(java.util.Map<? extends TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingLookup.inject(java.util.Map<? extends TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingReflection.inject(java.util.Map<? extends TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingUnsafe.inject(java.util.Map<? extends TypeDescription,byte[]> types)
static java.util.Map<TypeDescription,java.lang.Class<?>>	ByteArrayClassLoader.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types, java.security.ProtectionDomain protectionDomain, ByteArrayClassLoader.PersistenceHandler persistenceHandler, PackageDefinitionStrategy packageDefinitionStrategy, boolean childFirst, boolean forbidExisting)	Loads a given set of class descriptions and their binary representations.
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.Default.InjectionDispatcher.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.Default.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.Default.WrappingDispatcher.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.ForBootstrapInjection.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.ForUnsafeInjection.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.load(T classLoader, java.util.Map<TypeDescription,byte[]> types)	Loads a given collection of classes given their binary representation.
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.UsingLookup.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassReloadingStrategy.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	InjectionClassLoader.Strategy.load(InjectionClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)

Method parameters in net.bytebuddy.dynamic.loading with type arguments of type TypeDescription

Modifier and Type	Method	Description
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.inject(java.util.Map<? extends TypeDescription,byte[]> types)	Injects the given types into the represented class loader.
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingInstrumentation.inject(java.util.Map<? extends TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingLookup.inject(java.util.Map<? extends TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingReflection.inject(java.util.Map<? extends TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassInjector.UsingUnsafe.inject(java.util.Map<? extends TypeDescription,byte[]> types)
static java.util.Map<TypeDescription,java.lang.Class<?>>	ByteArrayClassLoader.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types, java.security.ProtectionDomain protectionDomain, ByteArrayClassLoader.PersistenceHandler persistenceHandler, PackageDefinitionStrategy packageDefinitionStrategy, boolean childFirst, boolean forbidExisting)	Loads a given set of class descriptions and their binary representations.
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.Default.InjectionDispatcher.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.Default.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.Default.WrappingDispatcher.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.ForBootstrapInjection.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.ForUnsafeInjection.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.load(T classLoader, java.util.Map<TypeDescription,byte[]> types)	Loads a given collection of classes given their binary representation.
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassLoadingStrategy.UsingLookup.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	ClassReloadingStrategy.load(java.lang.ClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
java.util.Map<TypeDescription,java.lang.Class<?>>	InjectionClassLoader.Strategy.load(InjectionClassLoader classLoader, java.util.Map<TypeDescription,byte[]> types)
static java.lang.ClassLoader	ByteArrayClassLoader.of(java.lang.ClassLoader parent, java.util.Map<TypeDescription,byte[]> typeDefinitions, java.security.ProtectionDomain protectionDomain, ByteArrayClassLoader.PersistenceHandler persistenceHandler, PackageDefinitionStrategy packageDefinitionStrategy, boolean childFirst)	Creates a new class loader for a given definition of classes.

Uses of TypeDescription in net.bytebuddy.dynamic.scaffold

Subinterfaces of TypeDescription in net.bytebuddy.dynamic.scaffold

Modifier and Type	Interface	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.

Classes in net.bytebuddy.dynamic.scaffold that implement TypeDescription

Modifier and Type	Class	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.

Fields in net.bytebuddy.dynamic.scaffold declared as TypeDescription

Modifier and Type	Field	Description
protected TypeDescription	FieldLocator.AbstractBase.accessingType	The type accessing the field.
protected TypeDescription	TypeInitializer.Drain.Default.instrumentedType	The instrumented type.
protected TypeDescription	TypeWriter.Default.ForInlining.InitializationHandler.Appending.instrumentedType	The instrumented type.
protected TypeDescription	TypeWriter.Default.instrumentedType	The instrumented type to be created.

Methods in net.bytebuddy.dynamic.scaffold that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	InstrumentedType.Default.getDeclaringType()
TypeDescription	InstrumentedType.Frozen.getDeclaringType()
TypeDescription	TypeWriter.MethodPool.Record.AccessBridgeWrapper.AccessorBridge.getDeclaringType()
TypeDescription	TypeWriter.MethodPool.Record.AccessBridgeWrapper.BridgeTarget.getDeclaringType()
TypeDescription	TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge.VisibilityBridge.getDeclaringType()
TypeDescription	InstrumentedType.Default.getEnclosingType()
TypeDescription	InstrumentedType.Frozen.getEnclosingType()
TypeDescription	MethodRegistry.Compiled.getInstrumentedType()	Returns the instrumented type that is to be created.
TypeDescription	MethodRegistry.Default.Compiled.getInstrumentedType()
TypeDescription	MethodRegistry.Default.Prepared.getInstrumentedType()
TypeDescription	MethodRegistry.Prepared.getInstrumentedType()	Returns the fully prepared instrumented type.
TypeDescription	InstrumentedType.Default.validated()
TypeDescription	InstrumentedType.Frozen.validated()
TypeDescription	InstrumentedType.validated()	Validates the instrumented type to define a legal Java type.

Methods in net.bytebuddy.dynamic.scaffold with parameters of type TypeDescription

Modifier and Type	Method	Description
protected MethodRegistry.Default.Prepared.Entry	MethodRegistry.Default.Entry.asPreparedEntry(TypeDescription instrumentedType, MethodDescription methodDescription, java.util.Set<MethodDescription.TypeToken> methodTypes, Visibility visibility)	Transforms this entry into a prepared state.
protected MethodRegistry.Default.Prepared.Entry	MethodRegistry.Default.Entry.asPreparedEntry(TypeDescription instrumentedType, MethodDescription methodDescription, Visibility visibility)	Transforms this entry into a prepared state.
protected TypeWriter.FieldPool.Record	FieldRegistry.Default.Compiled.Entry.bind(TypeDescription instrumentedType, FieldDescription fieldDescription)	Binds this entry to the provided field description.
protected TypeWriter.MethodPool.Record	MethodRegistry.Default.Compiled.Entry.bind(TypeDescription instrumentedType, boolean supportsBridges)	Transforms this entry into a method record.
FieldRegistry.Compiled	FieldRegistry.compile(TypeDescription instrumentedType)	Prepares the field registry for a given instrumented type.
FieldRegistry.Compiled	FieldRegistry.Default.compile(TypeDescription instrumentedType)
MethodGraph.Linked	MethodGraph.Compiler.AbstractBase.compile(TypeDescription typeDescription)
MethodGraph.Linked	MethodGraph.Compiler.compile(TypeDefinition typeDefinition, TypeDescription viewPoint)	Compiles the given type into a method graph.
MethodGraph.Linked	MethodGraph.Compiler.compile(TypeDescription typeDescription)	Compiles the given type into a method graph considering the type to be the viewpoint.
MethodGraph.Linked	MethodGraph.Compiler.Default.compile(TypeDefinition typeDefinition, TypeDescription viewPoint)
MethodGraph.Linked	MethodGraph.Compiler.ForDeclaredMethods.compile(TypeDefinition typeDefinition, TypeDescription viewPoint)
MethodGraph.Linked	MethodGraph.Compiler.ForDeclaredMethods.compile(TypeDescription typeDescription)
MethodGraph.Linked	MethodGraph.Empty.compile(TypeDefinition typeDefinition, TypeDescription viewPoint)
MethodGraph.Linked	MethodGraph.Empty.compile(TypeDescription typeDescription)
static <U> TypeWriter<U>	TypeWriter.Default.forRebasing(MethodRegistry.Prepared methodRegistry, TypeWriter.FieldPool fieldPool, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, TypePool typePool, TypeDescription originalType, ClassFileLocator classFileLocator, MethodRebaseResolver methodRebaseResolver)	Creates a type writer for rebasing a type.
static <U> TypeWriter<U>	TypeWriter.Default.forRedefinition(MethodRegistry.Prepared methodRegistry, TypeWriter.FieldPool fieldPool, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, TypePool typePool, TypeDescription originalType, ClassFileLocator classFileLocator)	Creates a type writer for redefining a type.
MethodGraph	MethodGraph.Empty.getInterfaceGraph(TypeDescription typeDescription)
MethodGraph	MethodGraph.Linked.Delegation.getInterfaceGraph(TypeDescription typeDescription)
MethodGraph	MethodGraph.Linked.getInterfaceGraph(TypeDescription typeDescription)	Returns a graph representing the view on this represented type's directly implemented interface type.
FieldLocator.Resolution	FieldLocator.AbstractBase.locate(java.lang.String name, TypeDescription type)
FieldLocator.Resolution	FieldLocator.locate(java.lang.String name, TypeDescription type)	Locates a field with the given name and type and throws an exception if no such type exists.
FieldLocator.Resolution	FieldLocator.NoOp.locate(java.lang.String name, TypeDescription type)
FieldLocator	FieldLocator.Factory.make(TypeDescription typeDescription)	Creates a field locator for a given type.
FieldLocator	FieldLocator.ForClassHierarchy.Factory.make(TypeDescription typeDescription)
FieldLocator	FieldLocator.ForExactType.Factory.make(TypeDescription typeDescription)
FieldLocator	FieldLocator.ForTopLevelType.Factory.make(TypeDescription typeDescription)
FieldLocator	FieldLocator.NoOp.make(TypeDescription typeDescription)
protected static TypeWriter.Default.ForInlining.InitializationHandler	TypeWriter.Default.ForInlining.InitializationHandler.Appending.of(boolean enabled, org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool methodPool, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Resolves an initialization handler.
static TypeWriter.MethodPool.Record	TypeWriter.MethodPool.Record.AccessBridgeWrapper.of(TypeWriter.MethodPool.Record delegate, TypeDescription instrumentedType, MethodDescription bridgeTarget, java.util.Set<MethodDescription.TypeToken> bridgeTypes, MethodAttributeAppender attributeAppender)	Wraps the given record in an accessor bridge wrapper if necessary.
static TypeWriter.MethodPool.Record	TypeWriter.MethodPool.Record.ForDefinedMethod.OfVisibilityBridge.of(TypeDescription instrumentedType, MethodDescription bridgeTarget, MethodAttributeAppender attributeAppender)	Creates a record for a visibility bridge.
InstrumentedType.WithFlexibleName	InstrumentedType.Factory.represent(TypeDescription typeDescription)	Creates an instrumented type that represents the provided type.
ElementMatcher<? super FieldDescription>	FieldRegistry.Default.Entry.resolve(TypeDescription typeDescription)
ElementMatcher<? super MethodDescription>	MethodRegistry.Default.Entry.resolve(TypeDescription typeDescription)

Constructors in net.bytebuddy.dynamic.scaffold with parameters of type TypeDescription

Constructor	Description
AbstractBase(TypeDescription accessingType)	Creates a new field locator.
AccessBridgeWrapper(TypeWriter.MethodPool.Record delegate, TypeDescription instrumentedType, MethodDescription bridgeTarget, java.util.Set<MethodDescription.TypeToken> bridgeTypes, MethodAttributeAppender attributeAppender)	Creates a wrapper for adding accessor bridges.
AccessorBridge(MethodDescription bridgeTarget, MethodDescription.TypeToken bridgeType, TypeDescription instrumentedType)	Creates a new accessor bridge method.
Appending(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Creates a new appending initialization handler.
BridgeTarget(MethodDescription bridgeTarget, TypeDescription instrumentedType)	Creates a new bridge target.
ClassDumpAction(java.lang.String target, TypeDescription instrumentedType, byte[] binaryRepresentation)	Creates a new class dump action.
Compiled(TypeDescription instrumentedType, java.util.List<FieldRegistry.Default.Compiled.Entry> entries)	Creates a new compiled field registry.
Compiled(TypeDescription instrumentedType, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, MethodList<?> methods, java.util.LinkedHashMap<MethodDescription,MethodRegistry.Default.Compiled.Entry> implementations, boolean supportsBridges)	Creates a new compiled version of a default method registry.
Compiled(TypeDescription instrumentedType)	Creates a new compiled handler for a visibility bridge.
Creating(TypeDescription instrumentedType, TypeWriter.MethodPool methodPool, AnnotationValueFilter.Factory annotationValueFilterFactory)	Creates a new creating initialization handler.
Default(java.lang.String name, int modifiers, TypeDescription.Generic superClass, java.util.List<? extends TypeVariableToken> typeVariables, java.util.List<? extends TypeDescription.Generic> interfaceTypes, java.util.List<? extends FieldDescription.Token> fieldTokens, java.util.List<? extends MethodDescription.Token> methodTokens, java.util.List<? extends AnnotationDescription> annotationDescriptions, TypeInitializer typeInitializer, LoadedTypeInitializer loadedTypeInitializer, TypeDescription declaringType, MethodDescription enclosingMethod, TypeDescription enclosingType, java.util.List<? extends TypeDescription> declaredTypes, boolean memberClass, boolean anonymousClass, boolean localClass)	Creates a new instrumented type.
Default(TypeDescription instrumentedType, TypeWriter.MethodPool methodPool, AnnotationValueFilter.Factory annotationValueFilterFactory)	Creates a new default type initializer drain.
Default(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, java.util.List<? extends DynamicType> auxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, TypePool typePool)	Creates a new default type writer.
Factory(TypeDescription typeDescription)	Creates a new factory for a field locator that locates a field for an exact type.
ForClassHierarchy(TypeDescription typeDescription)	Creates a field locator that looks up fields that are declared within a class's class hierarchy.
ForClassHierarchy(TypeDescription typeDescription, TypeDescription accessingType)	Creates a field locator that looks up fields that are declared within a class's class hierarchy.
ForCreation(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, TypeWriter.MethodPool methodPool, java.util.List<? extends DynamicType> auxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, TypePool typePool)	Creates a new default type writer for creating a new type that is not based on an existing class file.
ForExactType(TypeDescription typeDescription)	Creates a new field locator for locating fields from a declared type.
ForExactType(TypeDescription typeDescription, TypeDescription accessingType)	Creates a new field locator for locating fields from a declared type.
ForInlining(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, MethodRegistry.Prepared methodRegistry, Implementation.Target.Factory implementationTargetFactory, java.util.List<DynamicType> explicitAuxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, TypePool typePool, TypeDescription originalType, ClassFileLocator classFileLocator, MethodRebaseResolver methodRebaseResolver)	Creates a new default type writer for creating a new type that is not based on an existing class file.
ForTopLevelType(TypeDescription typeDescription)	Creates a new type locator for a top-level type.
Frozen(TypeDescription typeDescription, LoadedTypeInitializer loadedTypeInitializer)	Creates a new frozen representation of an instrumented type.
OfVisibilityBridge(MethodDescription visibilityBridge, MethodDescription bridgeTarget, TypeDescription bridgeType, MethodAttributeAppender attributeAppender)	Creates a new record for a visibility bridge.
Prepared(java.util.LinkedHashMap<MethodDescription,MethodRegistry.Default.Prepared.Entry> implementations, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeDescription instrumentedType, MethodGraph.Linked methodGraph, MethodList<?> methods)	Creates a prepared version of a default method registry.
VisibilityBridge(TypeDescription instrumentedType, MethodDescription bridgeTarget)	Creates a new visibility bridge.
WithActiveRecord(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Creates a new appending initialization handler with a drain and with an active record.
WithActiveRecord(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Creates a new appending initialization handler without a drain and with an active record.
WithDrain(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Creates a new appending initialization handler with a drain.
WithoutActiveRecord(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Creates a new appending initialization handler with a drain and without an active record.
WithoutActiveRecord(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory)	Creates a new appending initialization handler without a drain and without an active record.
WithoutDrain(org.objectweb.asm.MethodVisitor methodVisitor, TypeDescription instrumentedType, TypeWriter.MethodPool.Record record, AnnotationValueFilter.Factory annotationValueFilterFactory, boolean requireFrames, boolean expandFrames)	Creates a new appending initialization handler without a drain.

Constructor parameters in net.bytebuddy.dynamic.scaffold with type arguments of type TypeDescription

Constructor	Description
Delegation(MethodGraph methodGraph, MethodGraph superClassGraph, java.util.Map<TypeDescription,MethodGraph> interfaceGraphs)	Creates a new delegation method graph.

Uses of TypeDescription in net.bytebuddy.dynamic.scaffold.inline

Fields in net.bytebuddy.dynamic.scaffold.inline declared as TypeDescription

Modifier and Type	Field	Description
protected TypeDescription	AbstractInliningDynamicTypeBuilder.originalType	The original type that is being redefined or rebased.

Methods in net.bytebuddy.dynamic.scaffold.inline that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	MethodRebaseResolver.Resolution.ForRebasedConstructor.RebasedConstructor.getDeclaringType()
TypeDescription	MethodRebaseResolver.Resolution.ForRebasedMethod.RebasedMethod.getDeclaringType()
TypeDescription	RebaseImplementationTarget.getOriginType()
TypeDescription	RebaseImplementationTarget.RebasedMethodInvocation.getTypeDescription()

Methods in net.bytebuddy.dynamic.scaffold.inline with parameters of type TypeDescription

Modifier and Type	Method	Description
static MethodRebaseResolver	MethodRebaseResolver.Default.make(TypeDescription instrumentedType, java.util.Set<? extends MethodDescription.Token> rebaseableMethodTokens, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, MethodNameTransformer methodNameTransformer)	Creates a new method rebase resolver.
Implementation.Target	RebaseImplementationTarget.Factory.make(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion)
protected static LatentMatcher<MethodDescription>	InliningImplementationMatcher.of(LatentMatcher<? super MethodDescription> ignoredMethods, TypeDescription originalType)	Creates a matcher where only overridable or declared methods are matched unless those are ignored.
static MethodRebaseResolver.Resolution	MethodRebaseResolver.Resolution.ForRebasedConstructor.of(MethodDescription.InDefinedShape methodDescription, TypeDescription placeholderType)	Resolves a constructor rebasement.
static MethodRebaseResolver.Resolution	MethodRebaseResolver.Resolution.ForRebasedMethod.of(TypeDescription instrumentedType, MethodDescription.InDefinedShape methodDescription, MethodNameTransformer methodNameTransformer)	Resolves a rebasement for the provided method.
protected static ElementMatcher<MethodDescription.Token>	RebaseDynamicTypeBuilder.RebaseableMatcher.of(TypeDescription instrumentedType, MethodList<?> instrumentedMethods)	Returns a matcher that filters any method that should not be rebased.
protected static Implementation.Target	RebaseImplementationTarget.of(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion, MethodRebaseResolver methodRebaseResolver)	Creates a new rebase implementation target.
protected static Implementation.SpecialMethodInvocation	RebaseImplementationTarget.RebasedMethodInvocation.of(MethodDescription resolvedMethod, TypeDescription instrumentedType, StackManipulation additionalArguments)	Creates a special method invocation for the given method.
ElementMatcher<? super MethodDescription>	InliningImplementationMatcher.resolve(TypeDescription typeDescription)

Constructors in net.bytebuddy.dynamic.scaffold.inline with parameters of type TypeDescription

Constructor	Description
AbstractInliningDynamicTypeBuilder(InstrumentedType.WithFlexibleName instrumentedType, FieldRegistry fieldRegistry, MethodRegistry methodRegistry, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, Implementation.Context.Factory implementationContextFactory, MethodGraph.Compiler methodGraphCompiler, TypeValidation typeValidation, LatentMatcher<? super MethodDescription> ignoredMethods, TypeDescription originalType, ClassFileLocator classFileLocator)	Creates an inlining dynamic type builder.
RebasedConstructor(MethodDescription.InDefinedShape methodDescription, TypeDescription placeholderType)	Creates a new rebased constructor.
RebasedMethod(TypeDescription instrumentedType, MethodDescription.InDefinedShape methodDescription, MethodNameTransformer methodNameTransformer)	Creates a new rebased method.
RebasedMethodInvocation(MethodDescription methodDescription, TypeDescription instrumentedType, StackManipulation stackManipulation)	Creates a new rebased method invocation.
RebaseDynamicTypeBuilder(InstrumentedType.WithFlexibleName instrumentedType, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, Implementation.Context.Factory implementationContextFactory, MethodGraph.Compiler methodGraphCompiler, TypeValidation typeValidation, LatentMatcher<? super MethodDescription> ignoredMethods, TypeDescription originalType, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer)	Creates a rebase dynamic type builder.
RebaseDynamicTypeBuilder(InstrumentedType.WithFlexibleName instrumentedType, FieldRegistry fieldRegistry, MethodRegistry methodRegistry, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, Implementation.Context.Factory implementationContextFactory, MethodGraph.Compiler methodGraphCompiler, TypeValidation typeValidation, LatentMatcher<? super MethodDescription> ignoredMethods, TypeDescription originalType, ClassFileLocator classFileLocator, MethodNameTransformer methodNameTransformer)	Creates a rebase dynamic type builder.
RebaseImplementationTarget(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, Implementation.Target.AbstractBase.DefaultMethodInvocation defaultMethodInvocation, java.util.Map<MethodDescription.SignatureToken,MethodRebaseResolver.Resolution> rebaseableMethods)	Creates a rebase implementation target.
RedefinitionDynamicTypeBuilder(InstrumentedType.WithFlexibleName instrumentedType, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, Implementation.Context.Factory implementationContextFactory, MethodGraph.Compiler methodGraphCompiler, TypeValidation typeValidation, LatentMatcher<? super MethodDescription> ignoredMethods, TypeDescription originalType, ClassFileLocator classFileLocator)	Creates a redefinition dynamic type builder.
RedefinitionDynamicTypeBuilder(InstrumentedType.WithFlexibleName instrumentedType, FieldRegistry fieldRegistry, MethodRegistry methodRegistry, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, Implementation.Context.Factory implementationContextFactory, MethodGraph.Compiler methodGraphCompiler, TypeValidation typeValidation, LatentMatcher<? super MethodDescription> ignoredMethods, TypeDescription originalType, ClassFileLocator classFileLocator)	Creates a redefinition dynamic type builder.

Uses of TypeDescription in net.bytebuddy.dynamic.scaffold.subclass

Methods in net.bytebuddy.dynamic.scaffold.subclass with parameters of type TypeDescription

Modifier and Type	Method	Description
protected abstract java.util.List<MethodDescription.Token>	ConstructorStrategy.Default.doExtractConstructors(TypeDescription instrumentedType)	Extracts the relevant method tokens of the instrumented type's constructors.
java.util.List<MethodDescription.Token>	ConstructorStrategy.Default.extractConstructors(TypeDescription instrumentedType)
java.util.List<MethodDescription.Token>	ConstructorStrategy.Default.WithMethodAttributeAppenderFactory.extractConstructors(TypeDescription instrumentedType)
java.util.List<MethodDescription.Token>	ConstructorStrategy.extractConstructors(TypeDescription instrumentedType)	Extracts constructors for a given super type.
java.util.List<MethodDescription.Token>	ConstructorStrategy.ForDefaultConstructor.extractConstructors(TypeDescription instrumentedType)
protected abstract TypeDefinition	SubclassImplementationTarget.OriginTypeResolver.identify(TypeDescription typeDescription)	Identifies the origin type to a given type description.
MethodRegistry	ConstructorStrategy.Default.inject(TypeDescription instrumentedType, MethodRegistry methodRegistry)
MethodRegistry	ConstructorStrategy.Default.WithMethodAttributeAppenderFactory.inject(TypeDescription instrumentedType, MethodRegistry methodRegistry)
MethodRegistry	ConstructorStrategy.ForDefaultConstructor.inject(TypeDescription instrumentedType, MethodRegistry methodRegistry)
MethodRegistry	ConstructorStrategy.inject(TypeDescription instrumentedType, MethodRegistry methodRegistry)	Returns a method registry that is capable of creating byte code for the constructors that were provided by the ConstructorStrategy.extractConstructors(TypeDescription) method of this instance.
Implementation.Target	SubclassImplementationTarget.Factory.make(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion)
ElementMatcher<? super MethodDescription>	SubclassDynamicTypeBuilder.InstrumentableMatcher.resolve(TypeDescription typeDescription)

Constructors in net.bytebuddy.dynamic.scaffold.subclass with parameters of type TypeDescription

Constructor	Description
SubclassImplementationTarget(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, Implementation.Target.AbstractBase.DefaultMethodInvocation defaultMethodInvocation, SubclassImplementationTarget.OriginTypeResolver originTypeResolver)	Creates a new subclass implementation target.

Uses of TypeDescription in net.bytebuddy.implementation

Fields in net.bytebuddy.implementation declared as TypeDescription

Modifier and Type	Field	Description
protected TypeDescription	Implementation.Context.ExtractableView.AbstractBase.instrumentedType	The instrumented type.
protected TypeDescription	Implementation.Target.AbstractBase.instrumentedType	The instrumented type.

Methods in net.bytebuddy.implementation that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	Implementation.Context.Default.AccessorMethod.getDeclaringType()
TypeDescription	Implementation.Context.Default.CacheValueField.getDeclaringType()
TypeDescription	Implementation.Context.Default.FieldGetter.getDeclaringType()
TypeDescription	Implementation.Context.Default.FieldSetter.getDeclaringType()
protected TypeDescription	Implementation.Context.Default.FieldCacheEntry.getFieldType()	Returns the field type that is represented by this field cache entry.
TypeDescription	Implementation.Context.ExtractableView.AbstractBase.getInstrumentedType()
TypeDescription	Implementation.Context.getInstrumentedType()	Returns the instrumented type of the current implementation.
TypeDescription	Implementation.Target.AbstractBase.getInstrumentedType()
TypeDescription	Implementation.Target.getInstrumentedType()	Returns a description of the instrumented type.
TypeDescription	InvokeDynamic.InvocationProvider.Target.ForMethodDescription.getReturnType()
TypeDescription	InvokeDynamic.InvocationProvider.Target.Resolved.getReturnType()	Returns the requested return type.
TypeDescription	InvokeDynamic.InvocationProvider.Target.Resolved.Simple.getReturnType()
TypeDescription	Implementation.SpecialMethodInvocation.getTypeDescription()	Returns the target type the represented method is invoked on.
TypeDescription	Implementation.SpecialMethodInvocation.Illegal.getTypeDescription()
TypeDescription	Implementation.SpecialMethodInvocation.Simple.getTypeDescription()
TypeDescription	Implementation.Context.Default.register(AuxiliaryType auxiliaryType)
TypeDescription	Implementation.Context.Disabled.register(AuxiliaryType auxiliaryType)
TypeDescription	Implementation.Context.register(AuxiliaryType auxiliaryType)	Registers an auxiliary type as required for the current implementation.
TypeDescription	InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForExplicitType.resolve(MethodDescription methodDescription)
TypeDescription	InvokeDynamic.InvocationProvider.ReturnTypeProvider.ForInterceptedMethod.resolve(MethodDescription methodDescription)
TypeDescription	InvokeDynamic.InvocationProvider.ReturnTypeProvider.resolve(MethodDescription methodDescription)	Resolves the return type that is requested from the bootstrap method.

Methods in net.bytebuddy.implementation that return types with arguments of type TypeDescription

Modifier and Type	Method	Description
java.util.List<TypeDescription>	InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.getLoadedTypes()	Returns a list of all types of the arguments that were loaded onto the operand stack.
java.util.List<TypeDescription>	InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple.getLoadedTypes()
java.util.List<TypeDescription>	InvokeDynamic.InvocationProvider.Target.ForMethodDescription.getParameterTypes()
java.util.List<TypeDescription>	InvokeDynamic.InvocationProvider.Target.Resolved.getParameterTypes()	Returns the types of the values on the operand stack.
java.util.List<TypeDescription>	InvokeDynamic.InvocationProvider.Target.Resolved.Simple.getParameterTypes()

Methods in net.bytebuddy.implementation with parameters of type TypeDescription

Modifier and Type	Method	Description
protected abstract Implementation.SpecialMethodInvocation	Implementation.Target.AbstractBase.DefaultMethodInvocation.apply(MethodGraph.Node node, TypeDescription targetType)	Resolves a default method invocation for a given node.
abstract InvokeDynamic	InvokeDynamic.WithImplicitType.as(TypeDescription typeDescription)	Represents the last value as an instance of the given type.
InvokeDynamic	InvokeDynamic.WithImplicitType.OfArgument.as(TypeDescription typeDescription)
InvokeDynamic	InvokeDynamic.WithImplicitType.OfField.as(TypeDescription typeDescription)
InvokeDynamic	InvokeDynamic.WithImplicitType.OfInstance.as(TypeDescription typeDescription)
FieldDescription.InDefinedShape	Implementation.Context.cache(StackManipulation fieldValue, TypeDescription fieldType)	Caches a single value by storing it in form of a private, final and static field.
FieldDescription.InDefinedShape	Implementation.Context.Default.cache(StackManipulation fieldValue, TypeDescription fieldType)
FieldDescription.InDefinedShape	Implementation.Context.Disabled.cache(StackManipulation fieldValue, TypeDescription fieldType)
MethodDelegation.ImplementationDelegate.Compiled	MethodDelegation.ImplementationDelegate.compile(TypeDescription instrumentedType)	Compiles this implementation delegate.
MethodDelegation.ImplementationDelegate.Compiled	MethodDelegation.ImplementationDelegate.ForConstruction.compile(TypeDescription instrumentedType)
MethodDelegation.ImplementationDelegate.Compiled	MethodDelegation.ImplementationDelegate.ForField.compile(TypeDescription instrumentedType)
MethodDelegation.ImplementationDelegate.Compiled	MethodDelegation.ImplementationDelegate.ForStaticMethod.compile(TypeDescription instrumentedType)
FieldAccessor.AssignerConfigurable	FieldAccessor.ForImplicitProperty.in(TypeDescription typeDescription)
FieldAccessor.AssignerConfigurable	FieldAccessor.OwnerTypeLocatable.in(TypeDescription typeDescription)	Determines that a field should only be considered when it was defined in a given type.
InvokeDynamic.WithImplicitArguments	InvokeDynamic.WithImplicitTarget.invoke(java.lang.String methodName, TypeDescription returnType)	Requests the bootstrap method to bind a method with the given return type.
InvokeDynamic.WithImplicitArguments	InvokeDynamic.WithImplicitTarget.invoke(TypeDescription returnType)	Requests the bootstrap method to bind a method with the given return type.
Implementation.SpecialMethodInvocation	Implementation.Target.AbstractBase.invokeDefault(MethodDescription.SignatureToken token, TypeDescription targetType)
Implementation.SpecialMethodInvocation	Implementation.Target.invokeDefault(MethodDescription.SignatureToken token, TypeDescription targetType)	Creates a special method invocation for invoking a default method.
Implementation.Context.ExtractableView	Implementation.Context.Default.Factory.make(TypeDescription instrumentedType, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, TypeInitializer typeInitializer, ClassFileVersion classFileVersion, ClassFileVersion auxiliaryClassFileVersion)
Implementation.Context.ExtractableView	Implementation.Context.Disabled.Factory.make(TypeDescription instrumentedType, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, TypeInitializer typeInitializer, ClassFileVersion classFileVersion, ClassFileVersion auxiliaryClassFileVersion)
Implementation.Context.ExtractableView	Implementation.Context.Factory.make(TypeDescription instrumentedType, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, TypeInitializer typeInitializer, ClassFileVersion classFileVersion, ClassFileVersion auxiliaryClassFileVersion)	Creates a new implementation context.
Implementation.Target	Implementation.Target.Factory.make(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, ClassFileVersion classFileVersion)	Creates an implementation target.
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)	Creates any number of argument loaders for an instrumentation.
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForField.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForInstance.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForInstrumentedType.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForMethodParameter.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForMethodParameter.OfInstrumentedMethod.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForMethodParameterArray.ForInstrumentedMethod.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForNullConstant.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForStackManipulation.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
java.util.List<MethodCall.ArgumentLoader>	MethodCall.ArgumentLoader.ForThisReference.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodDescription invokedMethod)
static Implementation.SpecialMethodInvocation	Implementation.SpecialMethodInvocation.Simple.of(MethodDescription methodDescription, TypeDescription typeDescription)	Creates a special method invocation for a given invocation target.
protected static MethodDelegation.ImplementationDelegate	MethodDelegation.ImplementationDelegate.ForConstruction.of(TypeDescription typeDescription, MethodList<?> methods, MethodDelegationBinder methodDelegationBinder)	Creates an implementation delegate for constructing a new instance.
protected static StackManipulation	ToStringMethod.ValueConsumer.of(TypeDescription typeDescription)	Resolves an appropriate value resolver for a given type.
FieldAccessor.FieldLocation.Prepared	FieldAccessor.FieldLocation.Absolute.prepare(TypeDescription instrumentedType)
FieldAccessor.FieldLocation.Prepared	FieldAccessor.FieldLocation.prepare(TypeDescription instrumentedType)	A prepared field location.
FieldAccessor.FieldLocation.Prepared	FieldAccessor.FieldLocation.Relative.prepare(TypeDescription instrumentedType)
static Implementation	DefaultMethodCall.prioritize(TypeDescription... prioritizedInterface)	Creates a DefaultMethodCall implementation which searches the given list of interface types for a suitable default method in their order.
protected abstract StackManipulation	EqualsMethod.SuperClassCheck.resolve(TypeDescription instrumentedType)	Resolves a stack manipulation for the required super class check.
protected abstract StackManipulation	EqualsMethod.TypeCompatibilityCheck.resolve(TypeDescription instrumentedType)	Resolves a stack manipulation for the required type compatibility check.
StackManipulation	HashCodeMethod.OffsetProvider.ForFixedValue.resolve(TypeDescription instrumentedType)
StackManipulation	HashCodeMethod.OffsetProvider.ForSuperMethodCall.resolve(TypeDescription instrumentedType)
StackManipulation	HashCodeMethod.OffsetProvider.resolve(TypeDescription instrumentedType)	Resolves this offset provider for a given instrumented type.
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.WrappingArgumentProvider.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForBooleanConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForByteConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForCharacterConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForDoubleConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForEnumerationValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForField.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForFloatConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForInstance.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForIntegerConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodInstanceAndParameters.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForInterceptedMethodParameters.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForLongConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForMethodParameter.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForNullValue.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForShortConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForStringConstant.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved	InvokeDynamic.InvocationProvider.ArgumentProvider.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, Assigner.Typing typing)	Resolves an argument provider.
InvokeDynamic.InvocationProvider.Target.Resolved	InvokeDynamic.InvocationProvider.Default.Target.resolve(TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.Target.Resolved	InvokeDynamic.InvocationProvider.Target.ForMethodDescription.resolve(TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
InvokeDynamic.InvocationProvider.Target.Resolved	InvokeDynamic.InvocationProvider.Target.resolve(TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)	Resolves the target.
protected abstract StackManipulation	InvokeDynamic.TerminationHandler.resolve(MethodDescription interceptedMethod, TypeDescription returnType, Assigner assigner, Assigner.Typing typing)	Returns a stack manipulation that handles the method return.
MethodDescription	MethodCall.MethodLocator.ForElementMatcher.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
MethodDescription	MethodCall.MethodLocator.ForExplicitMethod.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
MethodDescription	MethodCall.MethodLocator.ForInstrumentedMethod.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod)
MethodDescription	MethodCall.MethodLocator.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod)	Resolves the method to be invoked.
StackManipulation	MethodCall.TargetHandler.ForConstructingInvocation.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForField.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForMethodParameter.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForSelfOrStaticInvocation.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.ForValue.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)
StackManipulation	MethodCall.TargetHandler.resolve(MethodDescription invokedMethod, MethodDescription instrumentedMethod, TypeDescription instrumentedType, Assigner assigner, Assigner.Typing typing)	Creates a stack manipulation that represents the method's invocation.
protected abstract FieldDescription	MethodDelegation.ImplementationDelegate.ForField.resolve(TypeDescription instrumentedType)	Resolves the field to which is delegated.
protected FieldDescription	MethodDelegation.ImplementationDelegate.ForField.WithInstance.resolve(TypeDescription instrumentedType)
protected FieldDescription	MethodDelegation.ImplementationDelegate.ForField.WithLookup.resolve(TypeDescription instrumentedType)
java.lang.String	ToStringMethod.PrefixResolver.ForFixedValue.resolve(TypeDescription instrumentedType)
java.lang.String	ToStringMethod.PrefixResolver.resolve(TypeDescription instrumentedType)	Resolves the prefixed value.
static Implementation	ExceptionMethod.throwing(TypeDescription exceptionType)	Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
static Implementation	ExceptionMethod.throwing(TypeDescription exceptionType, java.lang.String message)	Creates an implementation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
static MethodDelegation	MethodDelegation.to(TypeDescription typeDescription)	Delegates any intercepted method to invoke a static method that is declared by the supplied type.
MethodDelegation	MethodDelegation.WithCustomProperties.to(TypeDescription typeDescription)	Delegates any intercepted method to invoke a static method that is declared by the supplied type.
static MethodDelegation	MethodDelegation.toConstructor(TypeDescription typeDescription)	Delegates any intercepted method to invoke a constructor of the supplied type.
MethodDelegation	MethodDelegation.WithCustomProperties.toConstructor(TypeDescription typeDescription)	Delegates any intercepted method to invoke a constructor of the supplied type.
static FixedValue.AssignerConfigurable	FixedValue.value(TypeDescription fixedValue)	Returns the given type in form of a loaded type.
MethodCall	MethodCall.with(TypeDescription... typeDescription)	Defines the given types to be provided as arguments to the invoked method where the represented types are stored in the generated class's constant pool.
InvokeDynamic	InvokeDynamic.AbstractDelegator.withNullValue(TypeDescription... typeDescription)
InvokeDynamic	InvokeDynamic.withNullValue(TypeDescription... typeDescription)	Passes null values of the given types to the bootstrapped method.
InvokeDynamic	InvokeDynamic.AbstractDelegator.withThis(TypeDescription... typeDescription)
InvokeDynamic	InvokeDynamic.withThis(TypeDescription... typeDescription)	Passes references to this onto the operand stack where the instance is represented as the given types.
InvokeDynamic	InvokeDynamic.AbstractDelegator.withType(TypeDescription... typeDescription)
InvokeDynamic	InvokeDynamic.withType(TypeDescription... typeDescription)	Hands the provided types to the dynamically bound method.

Method parameters in net.bytebuddy.implementation with type arguments of type TypeDescription

Modifier and Type	Method	Description
static Implementation	DefaultMethodCall.prioritize(java.util.Collection<? extends TypeDescription> prioritizedInterfaces)	Creates a DefaultMethodCall implementation which searches the given list of interface types for a suitable default method in their order.

Constructors in net.bytebuddy.implementation with parameters of type TypeDescription

Constructor	Description
AbstractBase(TypeDescription instrumentedType, ClassFileVersion classFileVersion)	Create a new extractable view.
AbstractBase(TypeDescription instrumentedType, MethodGraph.Linked methodGraph, Implementation.Target.AbstractBase.DefaultMethodInvocation defaultMethodInvocation)	Creates a new implementation target.
AccessorMethod(TypeDescription instrumentedType, MethodDescription methodDescription, java.lang.String suffix)	Creates a new accessor method.
AccessorMethodDelegation(TypeDescription instrumentedType, java.lang.String suffix, MethodAccessorFactory.AccessType accessType, Implementation.SpecialMethodInvocation specialMethodInvocation)	Creates a delegation to an accessor method.
Appender(TypeDescription instrumentedType, StackManipulation baseline, java.util.List<FieldDescription.InDefinedShape> fieldDescriptions, ElementMatcher<? super FieldDescription.InDefinedShape> nonNullable)	Creates a new appender.
Appender(TypeDescription originType)	Creates a new appender.
Appender(TypeDescription instrumentedType)	Creates a new byte code appender for returning this.
Appender(TypeDescription instrumentedType, FieldDescription fieldDescription)	Creates a new appender.
Appender(TypeDescription instrumentedType)	Creates a new appender.
Appender(TypeDescription instrumentedType)	Creates a new byte code appender for an invoke dynamic implementation.
CacheValueField(TypeDescription instrumentedType, TypeDescription.Generic fieldType, java.lang.String suffix, int hashCode)	Creates a new cache value field.
Default(TypeDescription instrumentedType, ClassFileVersion classFileVersion, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, TypeInitializer typeInitializer, ClassFileVersion auxiliaryClassFileVersion)	Creates a new default implementation context.
Disabled(TypeDescription instrumentedType, ClassFileVersion classFileVersion)	Creates a new disabled implementation context.
ExceptionMethod(TypeDescription throwableType, ExceptionMethod.ConstructionDelegate constructionDelegate)	Creates a new instance of an implementation for throwing throwables.
FieldCacheEntry(StackManipulation fieldValue, TypeDescription fieldType)	Creates a new field cache entry.
FieldGetter(TypeDescription instrumentedType, FieldDescription fieldDescription, java.lang.String suffix)	Creates a new field getter.
FieldGetterDelegation(TypeDescription instrumentedType, java.lang.String suffix, MethodAccessorFactory.AccessType accessType, FieldDescription fieldDescription)	Creates a new field getter implementation.
FieldSetter(TypeDescription instrumentedType, FieldDescription fieldDescription, java.lang.String suffix)	Creates a new field setter.
FieldSetterDelegation(TypeDescription instrumentedType, java.lang.String suffix, MethodAccessorFactory.AccessType accessType, FieldDescription fieldDescription)	Creates a new field setter implementation.
ForClassConstant(TypeDescription typeDescription)	Creates a new argument provider for the given type description.
ForConstruction(TypeDescription typeDescription, java.util.List<MethodDelegationBinder.Record> records)	Creates a new compiled implementation delegate for a constructor delegation.
ForConstruction(TypeDescription typeDescription, java.util.List<MethodDelegationBinder.Record> records)	Creates an implementation delegate for constructing a new instance.
ForDefaultConstructor(TypeDescription exceptionType)	Creates a new construction delegate that calls a default constructor.
ForExplicitType(TypeDescription typeDescription)	Creates a new return type provider for an explicit return type.
ForInstance(java.lang.Object value, TypeDescription fieldType)	Creates a new argument provider that stores the given value in a static field.
ForInstrumentedType(TypeDescription instrumentedType)	Creates an argument loader for supporting the instrumented type as a type constant as an argument.
ForNullValue(TypeDescription typeDescription)	Creates a new argument provider for the null value.
ForPoolValue(StackManipulation valueLoadInstruction, TypeDescription loadedType)	Creates a new constant pool fixed value implementation.
ForStringConstructor(TypeDescription exceptionType, java.lang.String message)	Creates a new construction delegate that calls a constructor by handing it the given string.
ForThisInstance(TypeDescription typeDescription)	Creates a new argument provider for the instance of the instrumented type.
ForThisReference(TypeDescription instrumentedType)	Creates an argument loader that supplies the this instance as an argument.
ForVirtualInvocation(TypeDescription typeDescription)	Creates a new method invoking for a virtual method invocation.
Simple(MethodDescription methodDescription, TypeDescription typeDescription, StackManipulation stackManipulation)	Creates a new legal special method invocation.
Simple(StackManipulation stackManipulation, TypeDescription loadedType)	Creates a simple resolved argument provider.
Simple(StackManipulation stackManipulation, java.lang.String internalName, TypeDescription returnType, java.util.List<TypeDescription> parameterTypes)	Creates a new simple instance.
Target(java.lang.String internalName, TypeDescription returnType, java.util.List<InvokeDynamic.InvocationProvider.ArgumentProvider> argumentProviders, MethodDescription instrumentedMethod)	Creates a new target.
WithExplicitType(java.lang.String fieldName, FieldLocator.Factory fieldLocatorFactory, TypeDescription typeDescription)	Creates an argument provider for a field value with an explicit type.
WithExplicitType(int index, TypeDescription typeDescription)	Creates a new argument provider for a method parameter with an explicit type.

Constructor parameters in net.bytebuddy.implementation with type arguments of type TypeDescription

Constructor	Description
Appender(Implementation.Target implementationTarget, java.util.List<TypeDescription> prioritizedInterfaces)	Creates a new appender for implementing a DefaultMethodCall.
DefaultMethodCall(java.util.List<TypeDescription> prioritizedInterfaces)	Creates a new DefaultMethodCall implementation for a given list of prioritized interfaces.
Simple(StackManipulation stackManipulation, java.util.List<TypeDescription> loadedTypes)	Creates a simple resolved argument provider.
Simple(StackManipulation stackManipulation, java.lang.String internalName, TypeDescription returnType, java.util.List<TypeDescription> parameterTypes)	Creates a new simple instance.

Uses of TypeDescription in net.bytebuddy.implementation.attribute

Methods in net.bytebuddy.implementation.attribute with parameters of type TypeDescription

Modifier and Type	Method	Description
static void	AnnotationAppender.Default.apply(org.objectweb.asm.AnnotationVisitor annotationVisitor, TypeDescription valueType, java.lang.String name, java.lang.Object value)	Performs the writing of a given annotation value to an annotation visitor.
void	TypeAttributeAppender.apply(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, AnnotationValueFilter annotationValueFilter)	Applies this type attribute appender.
void	TypeAttributeAppender.Compound.apply(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, AnnotationValueFilter annotationValueFilter)
void	TypeAttributeAppender.Explicit.apply(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, AnnotationValueFilter annotationValueFilter)
void	TypeAttributeAppender.ForInstrumentedType.apply(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, AnnotationValueFilter annotationValueFilter)
void	TypeAttributeAppender.ForInstrumentedType.Differentiating.apply(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, AnnotationValueFilter annotationValueFilter)
void	TypeAttributeAppender.NoOp.apply(org.objectweb.asm.ClassVisitor classVisitor, TypeDescription instrumentedType, AnnotationValueFilter annotationValueFilter)
FieldAttributeAppender	FieldAttributeAppender.Explicit.make(TypeDescription typeDescription)
FieldAttributeAppender	FieldAttributeAppender.Factory.Compound.make(TypeDescription typeDescription)
FieldAttributeAppender	FieldAttributeAppender.Factory.make(TypeDescription typeDescription)	Returns a field attribute appender that is applicable for a given type description.
FieldAttributeAppender	FieldAttributeAppender.ForInstrumentedField.make(TypeDescription typeDescription)
FieldAttributeAppender	FieldAttributeAppender.NoOp.make(TypeDescription typeDescription)
MethodAttributeAppender	MethodAttributeAppender.Explicit.make(TypeDescription typeDescription)
MethodAttributeAppender	MethodAttributeAppender.Factory.Compound.make(TypeDescription typeDescription)
MethodAttributeAppender	MethodAttributeAppender.Factory.make(TypeDescription typeDescription)	Returns a method attribute appender that is applicable for a given type description.
MethodAttributeAppender	MethodAttributeAppender.ForInstrumentedMethod.make(TypeDescription typeDescription)
MethodAttributeAppender	MethodAttributeAppender.ForReceiverType.make(TypeDescription typeDescription)
MethodAttributeAppender	MethodAttributeAppender.NoOp.make(TypeDescription typeDescription)
AnnotationValueFilter	AnnotationValueFilter.Default.on(TypeDescription instrumentedType)
AnnotationValueFilter	AnnotationValueFilter.Factory.on(TypeDescription instrumentedType)	Creates an annotation value filter for writing annotations on an instrumented type.

Constructors in net.bytebuddy.implementation.attribute with parameters of type TypeDescription

Constructor	Description
Differentiating(TypeDescription typeDescription)	Creates a new differentiating type attribute appender.

Uses of TypeDescription in net.bytebuddy.implementation.auxiliary

Methods in net.bytebuddy.implementation.auxiliary with parameters of type TypeDescription

Modifier and Type	Method	Description
MethodGraph.Linked	MethodCallProxy.PrecomputedMethodGraph.compile(TypeDefinition typeDefinition, TypeDescription viewPoint)
MethodGraph.Linked	MethodCallProxy.PrecomputedMethodGraph.compile(TypeDescription typeDescription)
Implementation.SpecialMethodInvocation	TypeProxy.InvocationFactory.invoke(Implementation.Target implementationTarget, TypeDescription proxiedType, MethodDescription instrumentedMethod)	Creates a special method invocation to implement for a given method.
java.lang.String	AuxiliaryType.NamingStrategy.name(TypeDescription instrumentedType)	Names an auxiliary type.
java.lang.String	AuxiliaryType.NamingStrategy.SuffixingRandom.name(TypeDescription instrumentedType)

Constructors in net.bytebuddy.implementation.auxiliary with parameters of type TypeDescription

Constructor	Description
Appender(TypeDescription instrumentedType)	Creates a new appender.
ForDefaultMethod(TypeDescription proxiedType, Implementation.Target implementationTarget, boolean serializableProxy)	Creates a new proxy creation for a default interface type proxy.
ForSuperMethodByConstructor(TypeDescription proxiedType, Implementation.Target implementationTarget, java.util.List<TypeDescription> constructorParameters, boolean ignoreFinalizer, boolean serializableProxy)	Creates a new stack operation for creating a type proxy by calling one of its constructors.
ForSuperMethodByReflectionFactory(TypeDescription proxiedType, Implementation.Target implementationTarget, boolean ignoreFinalizer, boolean serializableProxy)	Creates a new stack operation for reflectively creating a type proxy for the given arguments.
TypeProxy(TypeDescription proxiedType, Implementation.Target implementationTarget, TypeProxy.InvocationFactory invocationFactory, boolean ignoreFinalizer, boolean serializableProxy)	Creates a new type proxy.

Constructor parameters in net.bytebuddy.implementation.auxiliary with type arguments of type TypeDescription

Constructor	Description
ForSuperMethodByConstructor(TypeDescription proxiedType, Implementation.Target implementationTarget, java.util.List<TypeDescription> constructorParameters, boolean ignoreFinalizer, boolean serializableProxy)	Creates a new stack operation for creating a type proxy by calling one of its constructors.

Uses of TypeDescription in net.bytebuddy.implementation.bind

Methods in net.bytebuddy.implementation.bind with parameters of type TypeDescription

Modifier and Type	Method	Description
static ArgumentTypeResolver.PrimitiveTypePrecedence	ArgumentTypeResolver.PrimitiveTypePrecedence.forPrimitive(TypeDescription typeDescription)	Locates the primitive type precedence for a given type.

Constructors in net.bytebuddy.implementation.bind with parameters of type TypeDescription

Constructor	Description
Virtual(TypeDescription typeDescription)	Creates an immutable method invoker that dispatches all methods on a given type.

Uses of TypeDescription in net.bytebuddy.implementation.bind.annotation

Methods in net.bytebuddy.implementation.bind.annotation that return TypeDescription

Modifier and Type	Method	Description
protected TypeDescription	FieldProxy.Binder.declaringType(AnnotationDescription.Loadable<FieldProxy> annotation)
protected TypeDescription	FieldValue.Binder.Delegate.declaringType(AnnotationDescription.Loadable<FieldValue> annotation)
protected abstract TypeDescription	TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFieldBinding.declaringType(AnnotationDescription.Loadable<S> annotation)	Extracts the declaring type from an annotation.
TypeDescription	FieldProxy.Binder.FieldResolver.ForGetter.getProxyType()
TypeDescription	FieldProxy.Binder.FieldResolver.ForGetterSetterPair.getProxyType()
TypeDescription	FieldProxy.Binder.FieldResolver.ForSetter.getProxyType()
TypeDescription	FieldProxy.Binder.FieldResolver.getProxyType()	Returns the type of the field access proxy.
TypeDescription	FieldProxy.Binder.FieldResolver.Unresolved.getProxyType()
TypeDescription	Default.Binder.TypeLocator.ForParameterType.resolve(TypeDescription.Generic parameterType)
TypeDescription	Default.Binder.TypeLocator.ForType.resolve(TypeDescription.Generic parameterType)
TypeDescription	Default.Binder.TypeLocator.resolve(TypeDescription.Generic parameterType)	Resolves the target type.
TypeDescription	Super.Binder.TypeLocator.ForInstrumentedType.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)
TypeDescription	Super.Binder.TypeLocator.ForParameterType.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)
TypeDescription	Super.Binder.TypeLocator.ForType.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)
TypeDescription	Super.Binder.TypeLocator.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)	Resolves the target type.

Methods in net.bytebuddy.implementation.bind.annotation with parameters of type TypeDescription

Modifier and Type	Method	Description
static TargetMethodAnnotationDrivenBinder.ParameterBinder<FieldProxy>	FieldProxy.Binder.install(TypeDescription typeDescription)	Creates a binder by installing a single proxy type where annotating a parameter with FieldProxy allows getting and setting values for a given field.
static TargetMethodAnnotationDrivenBinder.ParameterBinder<FieldProxy>	FieldProxy.Binder.install(TypeDescription getterType, TypeDescription setterType)	Creates a binder by installing two proxy types which are implemented by this binder if a field getter or a field setter is requested by using the FieldProxy annotation.
static TargetMethodAnnotationDrivenBinder.ParameterBinder<Morph>	Morph.Binder.install(TypeDescription typeDescription)	Installs a given type for use on a Morph annotation.
static TargetMethodAnnotationDrivenBinder.ParameterBinder<Pipe>	Pipe.Binder.install(TypeDescription typeDescription)	Installs a given type for use on a Pipe annotation.
protected static Default.Binder.TypeLocator	Default.Binder.TypeLocator.ForType.of(TypeDescription typeDescription)	Resolves a type locator based upon an annotation value.
protected static Super.Binder.TypeLocator	Super.Binder.TypeLocator.ForType.of(TypeDescription typeDescription)	Resolves a type locator based upon an annotation value.
protected abstract StackManipulation	Super.Instantiation.proxyFor(TypeDescription parameterType, Implementation.Target implementationTarget, AnnotationDescription.Loadable<Super> annotation)	Creates a stack manipulation which loads a super-call proxy onto the stack.
FieldProxy.Binder.FieldResolver	FieldProxy.Binder.FieldResolver.Factory.Duplex.resolve(TypeDescription parameterType, FieldDescription fieldDescription)
FieldProxy.Binder.FieldResolver	FieldProxy.Binder.FieldResolver.Factory.resolve(TypeDescription parameterType, FieldDescription fieldDescription)	Creates a field resolver.
FieldProxy.Binder.FieldResolver	FieldProxy.Binder.FieldResolver.Factory.Simplex.resolve(TypeDescription parameterType, FieldDescription fieldDescription)
TypeDescription	Super.Binder.TypeLocator.ForInstrumentedType.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)
TypeDescription	Super.Binder.TypeLocator.ForParameterType.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)
TypeDescription	Super.Binder.TypeLocator.ForType.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)
TypeDescription	Super.Binder.TypeLocator.resolve(TypeDescription instrumentedType, TypeDescription.Generic parameterType)	Resolves the target type.

Constructors in net.bytebuddy.implementation.bind.annotation with parameters of type TypeDescription

Constructor	Description
AccessorProxy(FieldDescription fieldDescription, TypeDescription instrumentedType, FieldProxy.Binder.FieldResolver fieldResolver, Assigner assigner, boolean serializableProxy)
Binder(TypeDescription proxyType, MethodDescription.InDefinedShape getterMethod, MethodDescription.InDefinedShape setterMethod)	Creates a new binder for a FieldProxy in duplex mode.
Duplex(TypeDescription proxyType, MethodDescription.InDefinedShape getterMethod, MethodDescription.InDefinedShape setterMethod)	Creates a new duplex factory.
Explicit(TypeDescription typeDescription)	Creates a new explicit default method locator.
Explicit(TypeDescription typeDescription)	Creates a new explicit default method locator.
ForExplicitType(TypeDescription typeDescription)	Creates a method locator for an explicit target.
ForGetterSetterPair(TypeDescription proxyType, MethodDescription.InDefinedShape getterMethod, MethodDescription.InDefinedShape setterMethod)	Creates a new field resolver for an accessor that both gets and sets a field value.
ForType(TypeDescription typeDescription)	Creates a new type locator for a given type.
ForType(TypeDescription typeDescription)	Creates a new type locator for a given type.
InstanceFieldConstructor(TypeDescription instrumentedType)	Creates a new implementation for implementing a field accessor proxy's constructor when accessing a non-static field.
InstanceFieldConstructor(TypeDescription instrumentedType)	Creates a new instance field constructor implementation.
Redirection(TypeDescription forwardingType, MethodDescription sourceMethod, Assigner assigner, boolean serializableProxy)	Creates a new redirection.
RedirectionProxy(TypeDescription morphingType, TypeDescription instrumentedType, Implementation.SpecialMethodInvocation specialMethodInvocation, Assigner assigner, boolean serializableProxy)	Creates a new redirection proxy.

Constructor parameters in net.bytebuddy.implementation.bind.annotation with type arguments of type TypeDescription

Constructor	Description
DelegationProcessor(java.util.Map<? extends TypeDescription,? extends TargetMethodAnnotationDrivenBinder.ParameterBinder<?>> parameterBinders)	Creates a new delegation processor.

Uses of TypeDescription in net.bytebuddy.implementation.bytecode

Methods in net.bytebuddy.implementation.bytecode with parameters of type TypeDescription

Modifier and Type	Method	Description
static StackManipulation	TypeCreation.of(TypeDescription typeDescription)	Creates a type creation for the given type.

Constructors in net.bytebuddy.implementation.bytecode with parameters of type TypeDescription

Constructor	Description
TypeCreation(TypeDescription typeDescription)	Constructs a new type creation.

Uses of TypeDescription in net.bytebuddy.implementation.bytecode.assign

Methods in net.bytebuddy.implementation.bytecode.assign with parameters of type TypeDescription

Modifier and Type	Method	Description
static StackManipulation	InstanceCheck.of(TypeDescription typeDescription)	Creates a new instance check.

Constructors in net.bytebuddy.implementation.bytecode.assign with parameters of type TypeDescription

Constructor	Description
InstanceCheck(TypeDescription typeDescription)	Creates a new instance check.
TypeCasting(TypeDescription typeDescription)	Creates a new type casting.

Uses of TypeDescription in net.bytebuddy.implementation.bytecode.collection

Constructors in net.bytebuddy.implementation.bytecode.collection with parameters of type TypeDescription

Constructor	Description
ForReferenceType(TypeDescription referenceType)	Creates a new array creator for a reference type.

Uses of TypeDescription in net.bytebuddy.implementation.bytecode.constant

Methods in net.bytebuddy.implementation.bytecode.constant with parameters of type TypeDescription

Modifier and Type	Method	Description
static StackManipulation	ClassConstant.of(TypeDescription typeDescription)	Returns a stack manipulation that loads a Class type onto the operand stack which represents the given type.

Constructors in net.bytebuddy.implementation.bytecode.constant with parameters of type TypeDescription

Constructor	Description
ForReferenceType(TypeDescription typeDescription)	Creates a stack manipulation that represents loading a class constant onto the stack.

Uses of TypeDescription in net.bytebuddy.implementation.bytecode.member

Methods in net.bytebuddy.implementation.bytecode.member with parameters of type TypeDescription

Modifier and Type	Method	Description
StackManipulation	MethodInvocation.IllegalInvocation.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
StackManipulation	MethodInvocation.Invocation.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
StackManipulation	MethodInvocation.OfGenericMethod.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)	Invokes the method as a bootstrap method to bind a call site with the given properties.
StackManipulation	MethodVariableAccess.MethodLoading.TypeCastingHandler.ForBridgeTarget.ofIndex(TypeDescription parameterType, int index)
StackManipulation	MethodVariableAccess.MethodLoading.TypeCastingHandler.NoOp.ofIndex(TypeDescription parameterType, int index)
StackManipulation	MethodVariableAccess.MethodLoading.TypeCastingHandler.ofIndex(TypeDescription parameterType, int index)	Yields a stack transformation to transform the given argument of the method for which the arguments are loaded onto the operand stack.
StackManipulation	MethodInvocation.IllegalInvocation.special(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.Invocation.special(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.OfGenericMethod.special(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.special(TypeDescription invocationTarget)	Transforms this method invocation into a special invocation on the given type.
StackManipulation	MethodInvocation.IllegalInvocation.virtual(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.Invocation.virtual(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.OfGenericMethod.virtual(TypeDescription invocationTarget)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.virtual(TypeDescription invocationTarget)	Transforms this method invocation into a virtual (or interface) method invocation on the given type.

Method parameters in net.bytebuddy.implementation.bytecode.member with type arguments of type TypeDescription

Modifier and Type	Method	Description
StackManipulation	MethodInvocation.IllegalInvocation.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
StackManipulation	MethodInvocation.Invocation.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
StackManipulation	MethodInvocation.OfGenericMethod.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)
StackManipulation	MethodInvocation.WithImplicitInvocationTargetType.dynamic(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> methodType, java.util.List<?> arguments)	Invokes the method as a bootstrap method to bind a call site with the given properties.

Constructors in net.bytebuddy.implementation.bytecode.member with parameters of type TypeDescription

Constructor	Description
DynamicInvocation(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes, MethodDescription.InDefinedShape bootstrapMethod, java.util.List<?> arguments)	Creates a new dynamic method invocation.
Invocation(MethodDescription.InDefinedShape methodDescription, TypeDescription typeDescription)	Creates an invocation of a given method on a given invocation target type.
OfGenericMethod(TypeDescription targetType, MethodInvocation.WithImplicitInvocationTargetType invocation)	Creates a generic method invocation.

Constructor parameters in net.bytebuddy.implementation.bytecode.member with type arguments of type TypeDescription

Constructor	Description
DynamicInvocation(java.lang.String methodName, TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes, MethodDescription.InDefinedShape bootstrapMethod, java.util.List<?> arguments)	Creates a new dynamic method invocation.

Uses of TypeDescription in net.bytebuddy.matcher

Classes in net.bytebuddy.matcher with type parameters of type TypeDescription

Modifier and Type	Class	Description
class	HasSuperTypeMatcher<T extends TypeDescription>	An element matcher that matches a super type.
class	InheritedAnnotationMatcher<T extends TypeDescription>	An element matcher that matches the list of inherited annotations of a type description.
class	SubTypeMatcher<T extends TypeDescription>	An element matcher that matches its argument for being another type's subtype.
class	SuperTypeMatcher<T extends TypeDescription>	An element matcher that matches its argument for being another type's super type.

Methods in net.bytebuddy.matcher with type parameters of type TypeDescription

Modifier and Type	Method	Description
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.hasAnnotation(ElementMatcher<? super AnnotationDescription> matcher)	Matches a list of annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.hasGenericSuperType(ElementMatcher<? super TypeDescription.Generic> matcher)	Matches any type description that declares a super type that matches the provided matcher.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.hasSuperType(ElementMatcher<? super TypeDescription> matcher)	Matches any type description that declares a super type that matches the provided matcher.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.inheritsAnnotation(java.lang.Class<?> type)	Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.inheritsAnnotation(TypeDescription type)	Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.inheritsAnnotation(ElementMatcher<? super TypeDescription> matcher)	Matches any annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isAnnotation()	Matches a TypeDescription that is an annotation type.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isInterface()	Matches a TypeDescription that is an interface.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isSubTypeOf(java.lang.Class<?> type)	Matches any type description that is a subtype of the given type.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isSubTypeOf(TypeDescription type)	Matches any type description that is a subtype of the given type.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isSuperTypeOf(java.lang.Class<?> type)	Matches any type description that is a super type of the given type.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isSuperTypeOf(TypeDescription type)	Matches any type description that is a super type of the given type.

Methods in net.bytebuddy.matcher with parameters of type TypeDescription

Modifier and Type	Method	Description
static <T extends AnnotationDescription> ElementMatcher.Junction<T>	ElementMatchers.annotationType(TypeDescription type)	Matches if an annotation is of a given type.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.canThrow(TypeDescription exceptionType)	Matches a MethodDescription by its capability to throw a given checked exception.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.declaresException(TypeDescription exceptionType)	Matches a method that declares the given generic exception type as a (erased) exception type.
static <T extends TypeDescription.Generic> ElementMatcher.Junction<T>	ElementMatchers.erasure(TypeDescription type)	Matches a generic type's erasure against the provided type.
static <T extends java.lang.Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>	ElementMatchers.erasures(TypeDescription... type)	Matches an iteration of generic types' erasures against the provided types.
static <T extends FieldDescription> ElementMatcher.Junction<T>	ElementMatchers.fieldType(TypeDescription fieldType)	Matches a field's raw type against the provided matcher.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.inheritsAnnotation(TypeDescription type)	Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
static <T extends ByteCodeElement> ElementMatcher.Junction<T>	ElementMatchers.isAccessibleTo(TypeDescription type)	Matches a ByteCodeElement that is accessible to a given Class.
static <T extends AnnotationSource> ElementMatcher.Junction<T>	ElementMatchers.isAnnotatedWith(TypeDescription type)	Matches an AnnotationSource for declared annotations.
static <T extends ByteCodeElement> ElementMatcher.Junction<T>	ElementMatchers.isDeclaredBy(TypeDescription type)	Matches a ByteCodeElement for being declared by a given TypeDescription.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.isGetter(TypeDescription type)	Matches any Java bean getter method which returns the given type.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.isOverriddenFrom(TypeDescription type)	Matches any virtual method with a signature that is compatible to a method that is declared the supplied type.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.isSetter(TypeDescription type)	Matches any Java bean setter method which takes an argument the given type.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isSubTypeOf(TypeDescription type)	Matches any type description that is a subtype of the given type.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.isSuperTypeOf(TypeDescription type)	Matches any type description that is a super type of the given type.
static <T extends ByteCodeElement> ElementMatcher.Junction<T>	ElementMatchers.isVisibleTo(TypeDescription type)	Matches a ByteCodeElement that is visible to a given TypeDescription.
ElementMatcher<? super S>	LatentMatcher.Conjunction.resolve(TypeDescription typeDescription)
ElementMatcher<? super S>	LatentMatcher.Disjunction.resolve(TypeDescription typeDescription)
ElementMatcher<? super FieldDescription>	LatentMatcher.ForFieldToken.resolve(TypeDescription typeDescription)
ElementMatcher<? super MethodDescription>	LatentMatcher.ForMethodToken.resolve(TypeDescription typeDescription)
ElementMatcher<? super MethodDescription>	LatentMatcher.ForSelfDeclaredMethod.resolve(TypeDescription typeDescription)
ElementMatcher<? super T>	LatentMatcher.resolve(TypeDescription typeDescription)	Resolves the element matcher this instance represents for the supplied type description.
ElementMatcher<? super S>	LatentMatcher.Resolved.resolve(TypeDescription typeDescription)
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.returns(TypeDescription type)	Matches MethodDescriptions that return a given erasure type.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.takesArgument(int index, TypeDescription type)	Matches MethodDescriptions that define a given type erasure as a parameter at the given index.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.takesArguments(TypeDescription... type)	Matches a method description that takes the provided raw arguments.

Method parameters in net.bytebuddy.matcher with type arguments of type TypeDescription

Modifier and Type	Method	Description
static <T extends AnnotationDescription> ElementMatcher.Junction<T>	ElementMatchers.annotationType(ElementMatcher<? super TypeDescription> matcher)	Matches if an annotation's type matches the supplied matcher.
static <T extends TypeDescription.Generic> ElementMatcher.Junction<T>	ElementMatchers.erasure(ElementMatcher<? super TypeDescription> matcher)	Converts a matcher for a type description into a matcher for the matched type's erasure.
static <T extends java.lang.Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>	ElementMatchers.erasures(java.lang.Iterable<? extends TypeDescription> types)	Matches an iteration of generic types' erasures against the provided types.
static <T extends java.lang.Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>	ElementMatchers.erasures(ElementMatcher<? super java.lang.Iterable<? extends TypeDescription>> matcher)	Applies the provided matchers to an iteration og generic types' erasures.
static <T extends FieldDescription> ElementMatcher.Junction<T>	ElementMatchers.fieldType(ElementMatcher<? super TypeDescription> matcher)	Matches a field's raw type against the provided matcher.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.hasSuperType(ElementMatcher<? super TypeDescription> matcher)	Matches any type description that declares a super type that matches the provided matcher.
static <T extends ParameterDescription> ElementMatcher.Junction<T>	ElementMatchers.hasType(ElementMatcher<? super TypeDescription> matcher)	Matches a parameter's type by the given matcher.
static <T extends TypeDescription> ElementMatcher.Junction<T>	ElementMatchers.inheritsAnnotation(ElementMatcher<? super TypeDescription> matcher)	Matches any annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
static <T extends AnnotationSource> ElementMatcher.Junction<T>	ElementMatchers.isAnnotatedWith(ElementMatcher<? super TypeDescription> matcher)	Matches an AnnotationSource for declared annotations.
static <T extends ByteCodeElement> ElementMatcher.Junction<T>	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 MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.isGetter(ElementMatcher<? super TypeDescription> matcher)	Matches any Java bean getter method which returns an value with a type matches the supplied matcher.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.isOverriddenFrom(ElementMatcher<? super TypeDescription> matcher)	Matches any virtual method with a signature that is compatible to a method that is declared by a type that matches the supplied matcher.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.isSetter(ElementMatcher<? super TypeDescription> matcher)	Matches any Java bean setter method which takes an argument that matches the supplied matcher.
static <T extends java.lang.ClassLoader> ElementMatcher.Junction<T>	ElementMatchers.ofType(ElementMatcher<? super TypeDescription> matcher)	Matches a class loader's type unless it is the bootstrap class loader which is never matched.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.returns(ElementMatcher<? super TypeDescription> matcher)	Matches a method's return type's erasure by the given matcher.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.takesArgument(int index, ElementMatcher<? super TypeDescription> matcher)	Matches MethodDescriptions that define a type erasure as a parameter at the given index that matches the supplied matcher.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.takesArguments(java.lang.Iterable<? extends TypeDescription> types)	Matches a method description that takes the provided raw arguments.
static <T extends MethodDescription> ElementMatcher.Junction<T>	ElementMatchers.takesArguments(ElementMatcher<? super java.lang.Iterable<? extends TypeDescription>> matchers)	Matches a MethodDescription by applying an iterable collection of element matcher on any parameter's TypeDescription.

Constructors in net.bytebuddy.matcher with parameters of type TypeDescription

Constructor	Description
AccessibilityMatcher(TypeDescription typeDescription)	Creates a matcher that validates that a byte code element can be seen by a given type.
SubTypeMatcher(TypeDescription typeDescription)	Creates a new matcher for matching its input for being a sub type of the given typeDescription.
SuperTypeMatcher(TypeDescription typeDescription)	Creates a new matcher for matching its input for being a super type of the given typeDescription.
VisibilityMatcher(TypeDescription typeDescription)	Creates a matcher that validates that a byte code element can be seen by a given type.

Constructor parameters in net.bytebuddy.matcher with type arguments of type TypeDescription

Constructor	Description
AnnotationTypeMatcher(ElementMatcher<? super TypeDescription> matcher)	Creates a new matcher for an annotation description's type.
CollectionErasureMatcher(ElementMatcher<? super java.lang.Iterable<? extends TypeDescription>> matcher)	Creates a new raw type matcher.
ErasureMatcher(ElementMatcher<? super TypeDescription> matcher)	Creates a new raw type matcher.
InstanceTypeMatcher(ElementMatcher<? super TypeDescription> matcher)	Creates a new instance type matcher.

Uses of TypeDescription in net.bytebuddy.pool

Classes in net.bytebuddy.pool that implement TypeDescription

Modifier and Type	Class	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.

Fields in net.bytebuddy.pool with type parameters of type TypeDescription

Modifier and Type	Field	Description
protected static java.util.Map<java.lang.String,TypeDescription>	TypePool.AbstractBase.PRIMITIVE_TYPES	A map of primitive types by their name.

Methods in net.bytebuddy.pool that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.LazyParameterizedType.asErasure()
TypeDescription	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested.LazyParameterizedType.asErasure()
TypeDescription	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType.LazyPrimitiveType.asErasure()
TypeDescription	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType.asErasure()
protected TypeDescription	TypePool.Default.WithLazyResolution.LazyTypeDescription.delegate()
protected TypeDescription	TypePool.LazyFacade.LazyTypeDescription.delegate()
TypeDescription	TypePool.Default.LazyTypeDescription.getDeclaringType()
TypeDescription	TypePool.Default.LazyTypeDescription.getEnclosingType()
TypeDescription	TypePool.Default.LazyTypeDescription.TypeContainment.getEnclosingType(TypePool typePool)	Returns the enclosing type or null if no such type exists.
TypeDescription	TypePool.Default.LazyTypeDescription.TypeContainment.SelfContained.getEnclosingType(TypePool typePool)
TypeDescription	TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod.getEnclosingType(TypePool typePool)
TypeDescription	TypePool.Default.LazyTypeDescription.TypeContainment.WithinType.getEnclosingType(TypePool typePool)
TypeDescription	TypePool.AbstractBase.RawEnumerationValue.LazyEnumerationDescription.getEnumerationType()
TypeDescription	TypePool.AbstractBase.ArrayTypeResolution.resolve()
TypeDescription	TypePool.AbstractBase.RawTypeValue.resolve()
TypeDescription	TypePool.Default.WithLazyResolution.LazyResolution.resolve()
TypeDescription	TypePool.LazyFacade.LazyResolution.resolve()
TypeDescription	TypePool.Resolution.Illegal.resolve()
TypeDescription	TypePool.Resolution.resolve()	Resolves this resolution to a TypeDescription.
TypeDescription	TypePool.Resolution.Simple.resolve()
protected TypeDescription	TypePool.Default.TypeExtractor.toTypeDescription()	Creates a type description from all data that is currently collected.

Methods in net.bytebuddy.pool with parameters of type TypeDescription

Modifier and Type	Method	Description
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.resolveInterfaceTypes(java.util.List<java.lang.String> interfaceTypeDescriptors, TypePool typePool, java.util.Map<java.lang.Integer,java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, TypeDescription definingType)	Resolves the generic interface types of the represented type.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized.resolveInterfaceTypes(java.util.List<java.lang.String> interfaceTypeDescriptors, TypePool typePool, java.util.Map<java.lang.Integer,java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, TypeDescription definingType)
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveInterfaceTypes(java.util.List<java.lang.String> interfaceTypeDescriptors, TypePool typePool, java.util.Map<java.lang.Integer,java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, TypeDescription definingType)
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveInterfaceTypes(java.util.List<java.lang.String> interfaceTypeDescriptors, TypePool typePool, java.util.Map<java.lang.Integer,java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, TypeDescription definingType)
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.resolveSuperClass(java.lang.String superClassDescriptor, TypePool typePool, java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription definingType)	Resolves the generic super type of the represented type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized.resolveSuperClass(java.lang.String superClassDescriptor, TypePool typePool, java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription definingType)
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveSuperClass(java.lang.String superClassDescriptor, TypePool typePool, java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription definingType)
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveSuperClass(java.lang.String superClassDescriptor, TypePool typePool, java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription definingType)

Constructors in net.bytebuddy.pool with parameters of type TypeDescription

Constructor	Description
LazyPrimitiveType(TypePool typePool, java.lang.String typePath, java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription typeDescription)	Creates a new lazy primitive type.
RawAnnotatedType(TypePool typePool, java.lang.String typePath, java.util.Map<java.lang.String,java.util.List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription typeDescription)	Creates a new raw annotated type.
Simple(TypeDescription typeDescription)	Creates a new successful resolution of a given type description.

Constructor parameters in net.bytebuddy.pool with type arguments of type TypeDescription

Constructor	Description
Explicit(java.util.Map<java.lang.String,TypeDescription> types)	Creates a new explicit type pool without a parent.
Explicit(TypePool parent, java.util.Map<java.lang.String,TypeDescription> types)	Creates a new explicit type pool.

Uses of TypeDescription in net.bytebuddy.utility

Methods in net.bytebuddy.utility that return TypeDescription

Modifier and Type	Method	Description
TypeDescription	JavaConstant.MethodHandle.getOwnerType()	Returns the owner type of this instance.
TypeDescription	JavaConstant.MethodHandle.getReturnType()	Returns the return type represented by this instance.
TypeDescription	JavaConstant.MethodType.getReturnType()	Returns the return type of this method type.
TypeDescription	JavaConstant.getType()	Returns a description of the type of the represented instance or at least a stub.
TypeDescription	JavaConstant.MethodHandle.getType()
TypeDescription	JavaConstant.MethodType.getType()
TypeDescription	JavaType.getTypeStub()	Returns at least a stub representing this type where the stub does not define any methods or fields.

Methods in net.bytebuddy.utility with parameters of type TypeDescription

Modifier and Type	Method	Description
static JavaConstant.MethodType	JavaConstant.MethodType.of(TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Returns a method type description of the given return type and parameter types.
static JavaConstant.MethodType	JavaConstant.MethodType.ofConstant(TypeDescription typeDescription)	Returns a method type for the given constant type.
static JavaConstant.MethodHandle	JavaConstant.MethodHandle.ofSpecial(MethodDescription.InDefinedShape methodDescription, TypeDescription typeDescription)	Creates a method handle representation of the given method for an explicit special method invocation of an otherwise virtual method.

Method parameters in net.bytebuddy.utility with type arguments of type TypeDescription

Modifier and Type	Method	Description
static JavaConstant.MethodType	JavaConstant.MethodType.of(TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Returns a method type description of the given return type and parameter types.

Constructors in net.bytebuddy.utility with parameters of type TypeDescription

Constructor	Description
MethodHandle(JavaConstant.MethodHandle.HandleType handleType, TypeDescription ownerType, java.lang.String name, TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a method handle representation.
MethodType(TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a method type for the given types.

Constructor parameters in net.bytebuddy.utility with type arguments of type TypeDescription

Constructor	Description
MethodHandle(JavaConstant.MethodHandle.HandleType handleType, TypeDescription ownerType, java.lang.String name, TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a method handle representation.
MethodType(TypeDescription returnType, java.util.List<? extends TypeDescription> parameterTypes)	Creates a method type for the given types.