Class TypeWriter.Default<S>

    • Field Detail

      • NO_REFERENCE

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

        protected static final java.lang.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.
      • auxiliaryTypes

        protected final java.util.List<? extends DynamicType> auxiliaryTypes
        The explicit auxiliary types to add to the created type.
      • 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.
      • 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 Detail

      • Default

        protected Default​(TypeDescription instrumentedType,
                          ClassFileVersion classFileVersion,
                          TypeWriter.FieldPool fieldPool,
                          TypeWriter.RecordComponentPool recordComponentPool,
                          java.util.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 Detail

      • forCreation

        public static <U> TypeWriter<U> forCreation​(MethodRegistry.Compiled methodRegistry,
                                                    java.util.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,
                                                        java.util.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,
                                                    java.util.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,
                                                      java.util.List<? extends DynamicType> auxiliaryTypes,
                                                      java.util.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.