Class TypeWriter.Default<S>

java.lang.Object
net.bytebuddy.dynamic.scaffold.TypeWriter.Default<S>
Type Parameters:
S - The best known loaded type for the dynamically created type.
All Implemented Interfaces:
TypeWriter<S>
Direct Known Subclasses:
TypeWriter.Default.ForCreation, TypeWriter.Default.ForInlining
Enclosing interface:
TypeWriter<T>

@Enhance public abstract static class TypeWriter.Default<S> extends Object implements TypeWriter<S>
A default implementation of a TypeWriter.
  • Field Details

    • NO_REFERENCE

      @AlwaysNull private static final String NO_REFERENCE
      Indicates an empty reference in a class file which is expressed by null.
    • DUMP_FOLDER

      @MaybeNull protected static final String DUMP_FOLDER
      A folder for dumping class files or null if no dump should be generated.
    • instrumentedType

      protected final TypeDescription instrumentedType
      The instrumented type to be created.
    • classFileVersion

      protected final ClassFileVersion classFileVersion
      The class file specified by the user.
    • fieldPool

      protected final TypeWriter.FieldPool fieldPool
      The field pool to use.
    • recordComponentPool

      protected final TypeWriter.RecordComponentPool recordComponentPool
      The record component pool to use.
    • auxiliaryTypes

      protected final List<? extends DynamicType> auxiliaryTypes
      The explicit auxiliary types to add to the created type.
    • fields

      protected final FieldList<FieldDescription.InDefinedShape> fields
      The instrumented type's declared fields.
    • methods

      protected final MethodList<?> methods
      The instrumented type's methods that are declared or inherited.
    • instrumentedMethods

      protected final MethodList<?> instrumentedMethods
      The instrumented methods relevant to this type creation.
    • recordComponents

      The instrumented type's record components.
    • loadedTypeInitializer

      protected final LoadedTypeInitializer loadedTypeInitializer
      The loaded type initializer to apply onto the created type after loading.
    • typeInitializer

      protected final TypeInitializer typeInitializer
      The type initializer to include in the created type's type initializer.
    • typeAttributeAppender

      protected final TypeAttributeAppender typeAttributeAppender
      The type attribute appender to apply onto the instrumented type.
    • asmVisitorWrapper

      protected final AsmVisitorWrapper asmVisitorWrapper
      The ASM visitor wrapper to apply onto the class writer.
    • annotationValueFilterFactory

      protected final AnnotationValueFilter.Factory annotationValueFilterFactory
      The annotation value filter factory to apply.
    • annotationRetention

      protected final AnnotationRetention annotationRetention
      The annotation retention to apply.
    • auxiliaryTypeNamingStrategy

      protected final AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy
      The naming strategy for auxiliary types to apply.
    • implementationContextFactory

      protected final Implementation.Context.Factory implementationContextFactory
      The implementation context factory to apply.
    • typeValidation

      protected final TypeValidation typeValidation
      Determines if a type should be explicitly validated.
    • classWriterStrategy

      protected final ClassWriterStrategy classWriterStrategy
      The class writer strategy to use.
    • typePool

      protected final TypePool typePool
      The type pool to use for computing stack map frames, if required.
  • Constructor Details

    • Default

      protected 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.
      Parameters:
      instrumentedType - The instrumented type to be created.
      classFileVersion - The class file specified by the user.
      fieldPool - The field pool to use.
      recordComponentPool - The record component pool to use.
      auxiliaryTypes - The explicit auxiliary types to add to the created type.
      fields - The instrumented type's declared fields.
      methods - The instrumented type's declared and virtually inherited methods.
      instrumentedMethods - The instrumented methods relevant to this type creation.
      recordComponents - The instrumented type's record components.
      loadedTypeInitializer - The loaded type initializer to apply onto the created type after loading.
      typeInitializer - The type initializer to include in the created type's type initializer.
      typeAttributeAppender - The type attribute appender to apply onto the instrumented type.
      asmVisitorWrapper - The ASM visitor wrapper to apply onto the class writer.
      annotationValueFilterFactory - The annotation value filter factory to apply.
      annotationRetention - The annotation retention to apply.
      auxiliaryTypeNamingStrategy - The naming strategy for auxiliary types to apply.
      implementationContextFactory - The implementation context factory to apply.
      typeValidation - Determines if a type should be explicitly validated.
      classWriterStrategy - The class writer strategy to use.
      typePool - The type pool to use for computing stack map frames, if required.
  • Method Details

    • doPrivileged

      @Enhance private static <T> T doPrivileged(PrivilegedAction<T> action)
      A proxy for java.security.AccessController#doPrivileged that is activated if available.
      Type Parameters:
      T - The type of the action's resolved value.
      Parameters:
      action - The action to execute from a privileged context.
      Returns:
      The action's resolved value.
    • doPrivileged

      @Enhance private static <T> T doPrivileged(PrivilegedExceptionAction<T> action) throws Exception
      A proxy for java.security.AccessController#doPrivileged that is activated if available.
      Type Parameters:
      T - The type of the action's resolved value.
      Parameters:
      action - The action to execute from a privileged context.
      Returns:
      The action's resolved value.
      Throws:
      Exception - If an exception occurs.
    • forCreation

      public static <U> TypeWriter<U> 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.
      Type Parameters:
      U - A loaded type that the instrumented type guarantees to subclass.
      Parameters:
      methodRegistry - The compiled method registry to use.
      auxiliaryTypes - A list of explicitly required auxiliary types.
      fieldPool - The field pool to use.
      recordComponentPool - The record component pool to use.
      typeAttributeAppender - The type attribute appender to apply onto the instrumented type.
      asmVisitorWrapper - The ASM visitor wrapper to apply onto the class writer.
      classFileVersion - The class file version to use when no explicit class file version is applied.
      annotationValueFilterFactory - The annotation value filter factory to apply.
      annotationRetention - The annotation retention to apply.
      auxiliaryTypeNamingStrategy - The naming strategy for auxiliary types to apply.
      implementationContextFactory - The implementation context factory to apply.
      typeValidation - Determines if a type should be explicitly validated.
      classWriterStrategy - The class writer strategy to use.
      typePool - The type pool to use for computing stack map frames, if required.
      Returns:
      A suitable type writer.
    • forRedefinition

      public static <U> TypeWriter<U> 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.
      Type Parameters:
      U - A loaded type that the instrumented type guarantees to subclass.
      Parameters:
      methodRegistry - The compiled method registry to use.
      auxiliaryTypes - A list of explicitly required auxiliary types.
      fieldPool - The field pool to use.
      recordComponentPool - The record component pool to use.
      typeAttributeAppender - The type attribute appender to apply onto the instrumented type.
      asmVisitorWrapper - The ASM visitor wrapper to apply onto the class writer.
      classFileVersion - The class file version to use when no explicit class file version is applied.
      annotationValueFilterFactory - The annotation value filter factory to apply.
      annotationRetention - The annotation retention to apply.
      auxiliaryTypeNamingStrategy - The naming strategy for auxiliary types to apply.
      implementationContextFactory - The implementation context factory to apply.
      typeValidation - Determines if a type should be explicitly validated.
      classWriterStrategy - The class writer strategy to use.
      typePool - The type pool to use for computing stack map frames, if required.
      originalType - The original type that is being redefined or rebased.
      classFileLocator - The class file locator for locating the original type's class file.
      Returns:
      A suitable type writer.
    • forRebasing

      public static <U> TypeWriter<U> 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.
      Type Parameters:
      U - A loaded type that the instrumented type guarantees to subclass.
      Parameters:
      methodRegistry - The compiled method registry to use.
      auxiliaryTypes - A list of explicitly required auxiliary types.
      fieldPool - The field pool to use.
      recordComponentPool - The record component pool to use.
      typeAttributeAppender - The type attribute appender to apply onto the instrumented type.
      asmVisitorWrapper - The ASM visitor wrapper to apply onto the class writer.
      classFileVersion - The class file version to use when no explicit class file version is applied.
      annotationValueFilterFactory - The annotation value filter factory to apply.
      annotationRetention - The annotation retention to apply.
      auxiliaryTypeNamingStrategy - The naming strategy for auxiliary types to apply.
      implementationContextFactory - The implementation context factory to apply.
      typeValidation - Determines if a type should be explicitly validated.
      classWriterStrategy - The class writer strategy to use.
      typePool - The type pool to use for computing stack map frames, if required.
      originalType - The original type that is being redefined or rebased.
      classFileLocator - The class file locator for locating the original type's class file.
      methodRebaseResolver - The method rebase resolver to use for rebasing names.
      Returns:
      A suitable type writer.
    • forDecoration

      public static <U> TypeWriter<U> 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.
      Type Parameters:
      U - A loaded type that the instrumented type guarantees to subclass.
      Parameters:
      instrumentedType - The instrumented type.
      classFileVersion - The class file version to use when no explicit class file version is applied.
      auxiliaryTypes - A list of explicitly required auxiliary types.
      methods - The methods to instrument.
      typeAttributeAppender - The type attribute appender to apply onto the instrumented type.
      asmVisitorWrapper - The ASM visitor wrapper to apply onto the class writer.
      annotationValueFilterFactory - The annotation value filter factory to apply.
      annotationRetention - The annotation retention to apply.
      auxiliaryTypeNamingStrategy - The naming strategy for auxiliary types to apply.
      implementationContextFactory - The implementation context factory to apply.
      typeValidation - Determines if a type should be explicitly validated.
      classWriterStrategy - The class writer strategy to use.
      typePool - The type pool to use for computing stack map frames, if required.
      classFileLocator - The class file locator for locating the original type's class file.
      Returns:
      A suitable type writer.
    • make

      public DynamicType.Unloaded<S> make(TypeResolutionStrategy.Resolved typeResolutionStrategy)
      Creates the dynamic type that is described by this type writer.
      Specified by:
      make in interface TypeWriter<S>
      Parameters:
      typeResolutionStrategy - The type resolution strategy to use.
      Returns:
      An unloaded dynamic type that describes the created type.
    • create

      protected abstract TypeWriter.Default<S>.UnresolvedType create(TypeInitializer typeInitializer, TypeWriter.Default.ClassDumpAction.Dispatcher dispatcher)
      Creates an unresolved version of the dynamic type.
      Parameters:
      typeInitializer - The type initializer to use.
      dispatcher - A dispatcher for dumping class files.
      Returns:
      An unresolved type.