Uses of Interface
net.bytebuddy.pool.TypePool

Packages that use TypePool

Package	Description
net.bytebuddy.agent.builder	An agent builder is used to easily implement load-time class-transformations using a Java agent.
net.bytebuddy.asm	The ASM package contains classes that are meant for direct interaction with the ASM API.
net.bytebuddy.build	A package for types that allow for applying Byte Buddy transformation during a build process.
net.bytebuddy.dynamic	This package contains classes and interfaces that are connected to writing the byte stream that represents a Java type that is dynamically created and for loading this type into a running JVM process.
net.bytebuddy.dynamic.scaffold	This package contains helper types and implementations that are responsible for the actual writing of a byte array representing a Java class.
net.bytebuddy.dynamic.scaffold.inline	All classes and types in this package are related to creating a DynamicType by enhancing a given type.
net.bytebuddy.dynamic.scaffold.subclass	All classes and types in this package are related to creating a DynamicType by creating a subclass of a given type.
net.bytebuddy.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 TypePool in net.bytebuddy.agent.builder

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

Modifier and Type	Method and Description
TypePool	AgentBuilder.ClassFileBufferStrategy.typePool(AgentBuilder.PoolStrategy poolStrategy, ClassFileLocator classFileLocator, ClassLoader classLoader, String name) Resolves the type pool for a given type name by the supplied AgentBuilder.PoolStrategy.
TypePool	AgentBuilder.PoolStrategy.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.Default.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.Eager.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.ClassLoading.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.WithTypePoolCache.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader, String name) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.Default.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader, String name) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.Eager.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader, String name) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.ClassLoading.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader, String name) Creates a type pool for a given class file locator.
TypePool	AgentBuilder.PoolStrategy.WithTypePoolCache.typePool(ClassFileLocator classFileLocator, ClassLoader classLoader, String name) Creates a type pool for a given class file locator.

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

Modifier and Type	Method and Description
TypeDescription	AgentBuilder.DescriptionStrategy.apply(String name, Class<?> type, TypePool typePool, AgentBuilder.CircularityLock circularityLock, ClassLoader classLoader, JavaModule module) Describes the given type.
TypeDescription	AgentBuilder.DescriptionStrategy.SuperTypeLoading.apply(String name, Class<?> type, TypePool typePool, AgentBuilder.CircularityLock circularityLock, ClassLoader classLoader, JavaModule module) Describes the given type.
TypeDescription	AgentBuilder.DescriptionStrategy.SuperTypeLoading.Asynchronous.apply(String name, Class<?> type, TypePool typePool, AgentBuilder.CircularityLock circularityLock, ClassLoader classLoader, JavaModule module) Describes the given type.
protected abstract Advice	AgentBuilder.Transformer.ForAdvice.Entry.resolve(Advice.WithCustomMapping advice, TypePool typePool, ClassFileLocator classFileLocator) Resolves the advice for this entry.
protected Advice	AgentBuilder.Transformer.ForAdvice.Entry.ForUnifiedAdvice.resolve(Advice.WithCustomMapping advice, TypePool typePool, ClassFileLocator classFileLocator)
protected Advice	AgentBuilder.Transformer.ForAdvice.Entry.ForSplitAdvice.resolve(Advice.WithCustomMapping advice, TypePool typePool, ClassFileLocator classFileLocator)

Uses of TypePool in net.bytebuddy.asm

Methods in net.bytebuddy.asm that return TypePool

Modifier and Type	Method and Description
TypePool	MemberSubstitution.TypePoolResolver.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
TypePool	MemberSubstitution.TypePoolResolver.OfImplicitPool.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
TypePool	MemberSubstitution.TypePoolResolver.ForExplicitPool.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
TypePool	MemberSubstitution.TypePoolResolver.ForClassFileLocator.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.

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

Modifier and Type	Method and Description
MemberSubstitution.Substitution	MemberSubstitution.Substitution.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.Stubbing.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.ForValue.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.ForFieldAccess.OfGivenField.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.ForFieldAccess.OfMatchedField.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.ForMethodInvocation.OfGivenMethod.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.ForMethodInvocation.OfMatchedMethod.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Substitution	MemberSubstitution.Substitution.Chain.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a substitution for an instrumented method.
MemberSubstitution.Replacement	MemberSubstitution.Replacement.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a replacement for an instrumented method.
MemberSubstitution.Replacement	MemberSubstitution.Replacement.Factory.Compound.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a replacement for an instrumented method.
MemberSubstitution.Replacement	MemberSubstitution.Replacement.NoOp.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a replacement for an instrumented method.
MemberSubstitution.Replacement	MemberSubstitution.Replacement.ForElementMatchers.Factory.make(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Creates a replacement for an instrumented method.
TypePool	MemberSubstitution.TypePoolResolver.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
TypePool	MemberSubstitution.TypePoolResolver.OfImplicitPool.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
TypePool	MemberSubstitution.TypePoolResolver.ForExplicitPool.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
TypePool	MemberSubstitution.TypePoolResolver.ForClassFileLocator.resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, TypePool typePool) Resolves a type pool to use for locating substituted members.
ClassVisitor	TypeReferenceAdjustment.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	TypeConstantAdjustment.wrap(TypeDescription instrumentedType, 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.
ModifierAdjustment.ModifierAdjustingClassVisitor	ModifierAdjustment.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	MemberRemoval.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	AsmVisitorWrapper.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	AsmVisitorWrapper.NoOp.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	AsmVisitorWrapper.ForDeclaredFields.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	AsmVisitorWrapper.ForDeclaredMethods.wrap(TypeDescription instrumentedType, 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.
ClassVisitor	AsmVisitorWrapper.Compound.wrap(TypeDescription instrumentedType, 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.
MethodVisitor	MemberSubstitution.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags) Wraps a method visitor.
MethodVisitor	MemberAttributeExtension.ForMethod.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags) Wraps a method visitor.
MethodVisitor	AsmVisitorWrapper.ForDeclaredMethods.MethodVisitorWrapper.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags) Wraps a method visitor.
MethodVisitor	AsmVisitorWrapper.ForDeclaredMethods.Entry.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags) Wraps a method visitor.
MethodVisitor	Advice.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags) Wraps a method visitor.

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

Constructor and Description
DispatchingVisitor(ClassVisitor classVisitor, TypeDescription instrumentedType, Implementation.Context implementationContext, TypePool typePool, Map<String,MethodDescription> methods, int writerFlags, int readerFlags) Creates a new dispatching visitor.
ForExplicitPool(TypePool typePool) Creates a resolver for an explicit type pool.
SubstitutingMethodVisitor(MethodVisitor methodVisitor, TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodGraph.Compiler methodGraphCompiler, boolean strict, MemberSubstitution.Replacement replacement, Implementation.Context implementationContext, TypePool typePool, boolean virtualPrivateCalls) Creates a new substituting method visitor.
TypeReferenceClassVisitor(ClassVisitor classVisitor, boolean strict, ElementMatcher<? super TypeDescription> filter, TypePool typePool) Creates a type reference class visitor.

Uses of TypePool in net.bytebuddy.build

Methods in net.bytebuddy.build that return TypePool

Modifier and Type	Method and Description
TypePool	Plugin.Engine.PoolStrategy.typePool(ClassFileLocator classFileLocator) Creates a type pool.
TypePool	Plugin.Engine.PoolStrategy.Default.typePool(ClassFileLocator classFileLocator) Creates a type pool.
TypePool	Plugin.Engine.PoolStrategy.Eager.typePool(ClassFileLocator classFileLocator) Creates a type pool.

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

Modifier and Type	Method and Description
ClassVisitor	RenamingPlugin.wrap(TypeDescription instrumentedType, 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.
MethodVisitor	AccessControllerPlugin.AccessControlWrapper.wrap(TypeDescription instrumentedType, MethodDescription instrumentedMethod, MethodVisitor methodVisitor, Implementation.Context implementationContext, TypePool typePool, int writerFlags, int readerFlags) Wraps a method visitor.

Uses of TypePool in net.bytebuddy.dynamic

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

Modifier and Type	Method and Description
DynamicType.Unloaded<T>	DynamicType.Builder.make(TypePool typePool) Creates the dynamic type this builder represents.
DynamicType.Unloaded<S>	DynamicType.Builder.AbstractBase.make(TypePool typePool) Creates the dynamic type this builder represents.
DynamicType.Unloaded<U>	DynamicType.Builder.AbstractBase.Delegator.make(TypePool typePool) Creates the dynamic type this builder represents.
DynamicType.Unloaded<T>	DynamicType.Builder.make(TypeResolutionStrategy typeResolutionStrategy, TypePool typePool) Creates the dynamic type this builder represents.
DynamicType.Unloaded<U>	DynamicType.Builder.AbstractBase.Delegator.make(TypeResolutionStrategy typeResolutionStrategy, TypePool typePool) Creates the dynamic type this builder represents.
DynamicType.Unloaded<U>	DynamicType.Builder.AbstractBase.UsingTypeWriter.make(TypeResolutionStrategy typeResolutionStrategy, TypePool typePool) Creates the dynamic type this builder represents.
protected abstract TypeWriter<U>	DynamicType.Builder.AbstractBase.UsingTypeWriter.toTypeWriter(TypePool typePool) Creates a TypeWriter given the specified TypePool.
ContextClassVisitor	DynamicType.Builder.wrap(ClassVisitor classVisitor, TypePool typePool) Wraps a class visitor with the configuration that is represented by this dynamic type builder.
ContextClassVisitor	DynamicType.Builder.AbstractBase.wrap(ClassVisitor classVisitor, TypePool typePool) Wraps a class visitor with the configuration that is represented by this dynamic type builder.
ContextClassVisitor	DynamicType.Builder.wrap(ClassVisitor classVisitor, TypePool typePool, int writerFlags, int readerFlags) Wraps a class visitor with the configuration that is represented by this dynamic type builder.
ContextClassVisitor	DynamicType.Builder.AbstractBase.Delegator.wrap(ClassVisitor classVisitor, TypePool typePool, int writerFlags, int readerFlags) Wraps a class visitor with the configuration that is represented by this dynamic type builder.
ContextClassVisitor	DynamicType.Builder.AbstractBase.UsingTypeWriter.wrap(ClassVisitor classVisitor, TypePool typePool, int writerFlags, int readerFlags) Wraps a class visitor with the configuration that is represented by this dynamic type builder.

Uses of TypePool in net.bytebuddy.dynamic.scaffold

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

Modifier and Type	Field and Description
protected TypePool	TypeWriter.Default.typePool The type pool to use for computing stack map frames, if required.

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

Modifier and Type	Method and Description
static <U> TypeWriter<U>	TypeWriter.Default.forCreation(MethodRegistry.Compiled methodRegistry, List<? extends DynamicType> auxiliaryTypes, TypeWriter.FieldPool fieldPool, TypeWriter.RecordComponentPool recordComponentPool, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool) Creates a type writer for creating a new type.
static <U> TypeWriter<U>	TypeWriter.Default.forDecoration(TypeDescription instrumentedType, ClassFileVersion classFileVersion, List<? extends DynamicType> auxiliaryTypes, List<? extends MethodDescription> methods, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool, ClassFileLocator classFileLocator) Creates a type writer for decorating a type.
static <U> TypeWriter<U>	TypeWriter.Default.forRebasing(MethodRegistry.Prepared methodRegistry, List<? extends DynamicType> auxiliaryTypes, TypeWriter.FieldPool fieldPool, TypeWriter.RecordComponentPool recordComponentPool, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, 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, List<? extends DynamicType> auxiliaryTypes, TypeWriter.FieldPool fieldPool, TypeWriter.RecordComponentPool recordComponentPool, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, ClassFileVersion classFileVersion, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool, TypeDescription originalType, ClassFileLocator classFileLocator) Creates a type writer for redefining a type.
ClassWriter	ClassWriterStrategy.resolve(int flags, TypePool typePool) Resolves a class writer.
ClassWriter	ClassWriterStrategy.Default.resolve(int flags, TypePool typePool) Resolves a class writer.
ClassWriter	ClassWriterStrategy.resolve(int flags, TypePool typePool, ClassReader classReader) Resolves a class writer.

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

Constructor and Description
Default(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, TypeWriter.RecordComponentPool recordComponentPool, List<? extends DynamicType> auxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, RecordComponentList<RecordComponentDescription.InDefinedShape> recordComponents, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool) Creates a new default type writer.
ForCreation(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, TypeWriter.MethodPool methodPool, TypeWriter.RecordComponentPool recordComponentPool, List<? extends DynamicType> auxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, RecordComponentList<RecordComponentDescription.InDefinedShape> recordComponents, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool) Creates a new default type writer for creating a new type that is not based on an existing class file.
ForInlining(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, TypeWriter.RecordComponentPool recordComponentPool, List<? extends DynamicType> auxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, RecordComponentList<RecordComponentDescription.InDefinedShape> recordComponents, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool, TypeDescription originalType, ClassFileLocator classFileLocator) Creates a new inlining type writer.
FrameComputingClassWriter(ClassReader classReader, int flags, TypePool typePool) Creates a new frame computing class writer.
FrameComputingClassWriter(int flags, TypePool typePool) Creates a new frame computing class writer.
WithDecorationOnly(TypeDescription instrumentedType, ClassFileVersion classFileVersion, List<? extends DynamicType> auxiliaryTypes, MethodList<?> methods, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool, ClassFileLocator classFileLocator) Creates a new inlining type writer that only applies a decoration.
WithFullProcessing(TypeDescription instrumentedType, ClassFileVersion classFileVersion, TypeWriter.FieldPool fieldPool, TypeWriter.RecordComponentPool recordComponentPool, List<? extends DynamicType> auxiliaryTypes, FieldList<FieldDescription.InDefinedShape> fields, MethodList<?> methods, MethodList<?> instrumentedMethods, RecordComponentList<RecordComponentDescription.InDefinedShape> recordComponents, LoadedTypeInitializer loadedTypeInitializer, TypeInitializer typeInitializer, TypeAttributeAppender typeAttributeAppender, AsmVisitorWrapper asmVisitorWrapper, AnnotationValueFilter.Factory annotationValueFilterFactory, AnnotationRetention annotationRetention, AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy, Implementation.Context.Factory implementationContextFactory, TypeValidation typeValidation, ClassWriterStrategy classWriterStrategy, TypePool typePool, TypeDescription originalType, ClassFileLocator classFileLocator, MethodRegistry.Prepared methodRegistry, Implementation.Target.Factory implementationTargetFactory, MethodRebaseResolver methodRebaseResolver) Creates a new inlining type writer that fully reprocesses a type.

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

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

Modifier and Type	Method and Description
protected TypeWriter<T>	RedefinitionDynamicTypeBuilder.toTypeWriter(TypePool typePool) Creates a TypeWriter given the specified TypePool.
protected TypeWriter<T>	RebaseDynamicTypeBuilder.toTypeWriter(TypePool typePool) Creates a TypeWriter given the specified TypePool.
protected TypeWriter<T>	DecoratingDynamicTypeBuilder.toTypeWriter(TypePool typePool) Creates a TypeWriter given the specified TypePool.

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

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

Modifier and Type	Method and Description
protected TypeWriter<T>	SubclassDynamicTypeBuilder.toTypeWriter(TypePool typePool) Creates a TypeWriter given the specified TypePool.

Uses of TypePool in net.bytebuddy.pool

Classes in net.bytebuddy.pool that implement TypePool

Modifier and Type	Class and Description
static class	TypePool.AbstractBase A base implementation of a TypePool that is managing a cache provider and that handles the description of array and primitive types.
static class	TypePool.AbstractBase.Hierarchical Implements a hierarchical view of type pools, similarly to class loader hierarchies.
static class	TypePool.ClassLoading A type pool that attempts to load a class.
static class	TypePool.Default A default implementation of a TypePool that models binary data in the Java byte code format into a TypeDescription.
static class	TypePool.Default.WithLazyResolution A variant of TypePool.Default that resolves type descriptions lazily.
static class	TypePool.Empty An empty type pool that cannot describe any type.
static class	TypePool.Explicit A type pool that supplies explicitly known type descriptions.
static class	TypePool.LazyFacade A lazy facade of a type pool that delegates any lookups to another type pool only if another value than the type's name is looked up.

Methods in net.bytebuddy.pool that return TypePool

Modifier and Type	Method and Description
static TypePool	TypePool.Default.of(ClassFileLocator classFileLocator) Creates a default TypePool that looks up data by querying the supplied class file locator.
static TypePool	TypePool.Default.WithLazyResolution.of(ClassFileLocator classFileLocator) Creates a default TypePool with lazy resolution that looks up data by querying the supplied class file locator.
static TypePool	TypePool.Default.of(ClassLoader classLoader) Returns a type pool for the provided class loader.
static TypePool	TypePool.Default.WithLazyResolution.of(ClassLoader classLoader) Returns a default TypePool with lazy resolution for the provided class loader.
static TypePool	TypePool.ClassLoading.of(ClassLoader classLoader) Returns a type pool that attempts type descriptions by loadings types from the given class loader.
static TypePool	TypePool.ClassLoading.of(ClassLoader classLoader, TypePool parent) Returns a type pool that attempts type descriptions by loadings types from the given class loader.
static TypePool	TypePool.Default.ofBootLoader() Creates a default TypePool that looks up data by querying the boot class loader.
static TypePool	TypePool.Default.WithLazyResolution.ofBootLoader() Creates a default TypePool with lazy resolution that looks up data by querying the boot class loader.
static TypePool	TypePool.ClassLoading.ofBootLoader() Returns a type pool that attempts type descriptions by loadings types from the bootstrap class loader.
static TypePool	TypePool.Default.ofPlatformLoader() Creates a default TypePool that looks up data by querying the plaform class loader.
static TypePool	TypePool.Default.WithLazyResolution.ofPlatformLoader() Creates a default TypePool with lazy resolution that looks up data by querying the platform class loader.
static TypePool	TypePool.ClassLoading.ofPlatformLoader() Returns a type pool that attempts type descriptions by loadings types from the platform class loader.
static TypePool	TypePool.Default.ofSystemLoader() Creates a default TypePool that looks up data by querying the system class loader.
static TypePool	TypePool.Default.WithLazyResolution.ofSystemLoader() Creates a default TypePool with lazy resolution that looks up data by querying the system class loader.
static TypePool	TypePool.ClassLoading.ofSystemLoader() Returns a type pool that attempts type descriptions by loadings types from the system class loader.
static TypePool	TypePool.Explicit.wrap(TypeDescription instrumentedType, List<? extends DynamicType> auxiliaryTypes, TypePool typePool) Wraps another type pool for an instrumented type and its auxiliary types.

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

Modifier and Type	Method and Description
MethodDescription.InDefinedShape	TypePool.Default.LazyTypeDescription.TypeContainment.getEnclosingMethod(TypePool typePool) Returns the enclosing method or null if no such method exists.
MethodDescription.InDefinedShape	TypePool.Default.LazyTypeDescription.TypeContainment.SelfContained.getEnclosingMethod(TypePool typePool) Returns the enclosing method or null if no such method exists.
MethodDescription.InDefinedShape	TypePool.Default.LazyTypeDescription.TypeContainment.WithinType.getEnclosingMethod(TypePool typePool) Returns the enclosing method or null if no such method exists.
MethodDescription.InDefinedShape	TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod.getEnclosingMethod(TypePool typePool) Returns the enclosing method or null if no such method exists.
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) Returns the enclosing type or null if no such type exists.
TypeDescription	TypePool.Default.LazyTypeDescription.TypeContainment.WithinType.getEnclosingType(TypePool typePool) Returns the enclosing type or null if no such type exists.
TypeDescription	TypePool.Default.LazyTypeDescription.TypeContainment.WithinMethod.getEnclosingType(TypePool typePool) Returns the enclosing type or null if no such type exists.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUnboundWildcard.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForRawType.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
boolean	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested.isPrimaryBound(TypePool typePool) Determines if a generic type tokens represents a primary bound of a type variable.
static TypePool	TypePool.ClassLoading.of(ClassLoader classLoader, TypePool parent) Returns a type pool that attempts type descriptions by loadings types from the given class loader.
protected static TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType.LazyRawAnnotatedTypeList.of(TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, List<String> descriptors) Creates generic type list only representing raw types.
protected static TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.RawAnnotatedType.of(TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, String descriptor) Creates a new raw annotated type.
protected static TypeDescription.Generic	TypePool.Default.LazyTypeDescription.TokenizedGenericType.of(TypePool typePool, TypePool.Default.LazyTypeDescription.GenericTypeToken genericTypeToken, String rawTypeDescriptor, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeVariableSource typeVariableSource) Creates a new generic type description for a tokenized generic type.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveExceptionTypes(List<String> exceptionTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveExceptionTypes(List<String> exceptionTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.resolveExceptionTypes(List<String> exceptionTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized.resolveExceptionTypes(List<String> exceptionTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveFieldType(String fieldTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, FieldDescription.InDefinedShape definingField) Resolves the field type of the represented field.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveFieldType(String fieldTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, FieldDescription.InDefinedShape definingField) Resolves the field type of the represented field.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField.resolveFieldType(String fieldTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, FieldDescription.InDefinedShape definingField) Resolves the field type of the represented field.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForField.Tokenized.resolveFieldType(String fieldTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, FieldDescription.InDefinedShape definingField) Resolves the field type of the represented field.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveInterfaceTypes(List<String> interfaceTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, TypeDescription definingType) Resolves the generic interface types of the represented type.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveInterfaceTypes(List<String> interfaceTypeDescriptors, TypePool typePool, Map<Integer,Map<String,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.resolveInterfaceTypes(List<String> interfaceTypeDescriptors, TypePool typePool, Map<Integer,Map<String,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(List<String> interfaceTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, TypeDescription definingType) Resolves the generic interface types of the represented type.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveParameterTypes(List<String> parameterTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveParameterTypes(List<String> parameterTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.resolveParameterTypes(List<String> parameterTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized.resolveParameterTypes(List<String> parameterTypeDescriptors, TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the generic parameter types of the represented method.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveRecordType(String recordTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, RecordComponentDescription.InDefinedShape definingRecordComponent) Resolves a record component's type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveRecordType(String recordTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, RecordComponentDescription.InDefinedShape definingRecordComponent) Resolves a record component's type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForRecordComponent.resolveRecordType(String recordTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, RecordComponentDescription.InDefinedShape definingRecordComponent) Resolves a record component's type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForRecordComponent.Tokenized.resolveRecordType(String recordTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, RecordComponentDescription.InDefinedShape definingRecordComponent) Resolves a record component's type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveReturnType(String returnTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the return type of the represented method.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveReturnType(String returnTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the return type of the represented method.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.resolveReturnType(String returnTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the return type of the represented method.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized.resolveReturnType(String returnTypeDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, MethodDescription.InDefinedShape definingMethod) Resolves the return type of the represented method.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveSuperClass(String superClassDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription definingType) Resolves the generic super type of the represented type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveSuperClass(String superClassDescriptor, TypePool typePool, Map<String,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.resolveSuperClass(String superClassDescriptor, TypePool typePool, Map<String,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(String superClassDescriptor, TypePool typePool, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription definingType) Resolves the generic super type of the represented type.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.resolveTypeVariables(TypePool typePool, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> boundAnnotationTokens) Resolves the type variables of the represented element.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Raw.resolveTypeVariables(TypePool typePool, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> boundAnnotationTokens) Resolves the type variables of the represented element.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.Malformed.resolveTypeVariables(TypePool typePool, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> boundAnnotationTokens) Resolves the type variables of the represented element.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForType.Tokenized.resolveTypeVariables(TypePool typePool, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> boundAnnotationTokens) Resolves the type variables of the represented element.
TypeList.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.Resolution.ForMethod.Tokenized.resolveTypeVariables(TypePool typePool, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> boundAnnotationTokens) Resolves the type variables of the represented element.
protected static TypeDescription	TypePool.Default.LazyTypeDescription.TokenizedGenericType.toErasure(TypePool typePool, String descriptor) Creates a type description from a descriptor by looking up the corresponding type.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.OfFormalTypeVariable.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> boundaryAnnotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.Formal.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> boundaryAnnotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForPrimitiveType.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUnboundWildcard.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForRawType.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForTypeVariable.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForGenericArray.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForLowerBoundWildcard.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForUpperBoundWildcard.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
TypeDescription.Generic	TypePool.Default.LazyTypeDescription.GenericTypeToken.ForParameterizedType.Nested.toGenericType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Transforms this token into a generic type representation.
static TypePool	TypePool.Explicit.wrap(TypeDescription instrumentedType, List<? extends DynamicType> auxiliaryTypes, TypePool typePool) Wraps another type pool for an instrumented type and its auxiliary types.

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

Constructor and Description
AnnotatedTypeVariable(TypePool typePool, List<TypePool.Default.LazyTypeDescription.AnnotationToken> annotationTokens, TypeDescription.Generic typeVariable) Creates a new annotated type variable.
ClassLoading(TypePool.CacheProvider cacheProvider, TypePool parent, ClassLoader classLoader) Creates a class loadings type pool.
Default(TypePool.CacheProvider cacheProvider, ClassFileLocator classFileLocator, TypePool.Default.ReaderMode readerMode, TypePool parentPool) Creates a new default type pool.
Explicit(TypePool parent, Map<String,TypeDescription> types) Creates a new explicit type pool.
ForAnnotationProperty(TypePool typePool, String annotationDescriptor) Creates a new component type locator for an array value.
ForWildcardBound(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypePool.Default.LazyTypeDescription.GenericTypeToken genericTypeToken)
Hierarchical(TypePool.CacheProvider cacheProvider, TypePool parent) Creates a hierarchical type pool.
LazyBoundTokenList(TypePool typePool, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, List<TypePool.Default.LazyTypeDescription.GenericTypeToken> boundTypeTokens) Creates a new lazy bound token list for a type variable.
LazyFacade(TypePool typePool) Creates a lazy facade for a type pool.
LazyGenericArray(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypePool.Default.LazyTypeDescription.GenericTypeToken componentTypeToken) Creates a new lazy generic array.
LazyLowerBoundWildcard(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypePool.Default.LazyTypeDescription.GenericTypeToken boundTypeToken) Creates a new lazy lower bound wildcard.
LazyNestMemberList(TypeDescription typeDescription, TypePool typePool, List<String> nestMembers) Creates a new lazy type list of all nest members of this group.
LazyParameterizedType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, String name, List<TypePool.Default.LazyTypeDescription.GenericTypeToken> parameterTypeTokens) Creates a new description of a parameterized type.
LazyParameterizedType(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, String name, List<TypePool.Default.LazyTypeDescription.GenericTypeToken> parameterTypeTokens, TypePool.Default.LazyTypeDescription.GenericTypeToken ownerTypeToken) Creates a new lazy parameterized type.
LazyPrimitiveType(TypePool typePool, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription typeDescription) Creates a new lazy primitive type.
LazyRawAnnotatedTypeList(TypePool typePool, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, List<String> descriptors) Creates a generic type list only representing raw types.
LazyResolution(TypePool typePool, String name) Creates a lazy resolution for a lazy facade for a type pool.
LazyTokenList(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, List<TypePool.Default.LazyTypeDescription.GenericTypeToken> genericTypeTokens) Creates a new type list that represents a list of tokenized types.
LazyTypeDescription(TypePool typePool, int actualModifiers, int modifiers, String name, String superClassInternalName, String[] interfaceInternalName, String genericSignature, TypePool.Default.LazyTypeDescription.TypeContainment typeContainment, String declaringTypeInternalName, List<String> declaredTypes, boolean anonymousType, String nestHostInternalName, List<String> nestMemberInternalNames, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> superClassAnnotationTokens, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> interfaceAnnotationTokens, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> typeVariableAnnotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> typeVariableBoundsAnnotationTokens, List<TypePool.Default.LazyTypeDescription.AnnotationToken> annotationTokens, List<TypePool.Default.LazyTypeDescription.FieldToken> fieldTokens, List<TypePool.Default.LazyTypeDescription.MethodToken> methodTokens, List<TypePool.Default.LazyTypeDescription.RecordComponentToken> recordComponentTokens, List<String> permittedSubclasses, ClassFileVersion classFileVersion) Creates a new lazy type description.
LazyTypeDescription(TypePool typePool, String name) Creates a new lazy type resolution.
LazyTypeList(TypePool typePool, List<String> descriptors) Creates a list of lazy type descriptions.
LazyTypeVariable(TypePool typePool, TypeVariableSource typeVariableSource, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> boundaryAnnotationTokens, String symbol, List<TypePool.Default.LazyTypeDescription.GenericTypeToken> boundTypeTokens) Creates a lazy type description of a type variables.
LazyUnboundWildcard(TypePool typePool, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens) Creates a new lazy unbound wildcard.
LazyUpperBoundWildcard(TypePool typePool, TypeVariableSource typeVariableSource, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypePool.Default.LazyTypeDescription.GenericTypeToken boundTypeToken) Creates a new lazy upper bound wildcard.
Malformed(TypePool typePool, String rawTypeDescriptor) Creates a lazy description of a non-well-defined described generic type.
RawAnnotatedType(TypePool typePool, String typePath, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeDescription typeDescription) Creates a new raw annotated type.
TokenizedGenericType(TypePool typePool, TypePool.Default.LazyTypeDescription.GenericTypeToken genericTypeToken, String rawTypeDescriptor, Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>> annotationTokens, TypeVariableSource typeVariableSource) Creates a new tokenized generic type.
TokenList(TypePool typePool, List<String> rawTypeDescriptors) Creates a new tokenized list of generic types.
TypeVariableList(TypePool typePool, List<TypePool.Default.LazyTypeDescription.GenericTypeToken.OfFormalTypeVariable> typeVariables, TypeVariableSource typeVariableSource, Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>> annotationTokens, Map<Integer,Map<Integer,Map<String,List<TypePool.Default.LazyTypeDescription.AnnotationToken>>>> boundAnnotationTokens) Creates a list of type variables.
UnresolvedTypeVariable(TypeVariableSource typeVariableSource, TypePool typePool, String symbol, List<TypePool.Default.LazyTypeDescription.AnnotationToken> annotationTokens) Creates an unresolved type variable.
WithLazyResolution(TypePool.CacheProvider cacheProvider, ClassFileLocator classFileLocator, TypePool.Default.ReaderMode readerMode, TypePool parentPool) Creates a new default type pool with lazy resolution.

Uses of TypePool in net.bytebuddy.utility

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

Modifier and Type	Method and Description
static JavaConstant	JavaConstant.Simple.ofDescription(Object value, TypePool typePool) Creates a Java constant value from a java.lang.constant.ConstantDesc.