Class TypeWriter.Default<S>

    • Field Detail

      • 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.
      • 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,
                          java.util.List<? extends DynamicType> auxiliaryTypes,
                          FieldList<FieldDescription.InDefinedShape> fields,
                          MethodList<?> methods,
                          MethodList<?> instrumentedMethods,
                          LoadedTypeInitializer loadedTypeInitializer,
                          TypeInitializer typeInitializer,
                          TypeAttributeAppender typeAttributeAppender,
                          AsmVisitorWrapper asmVisitorWrapper,
                          AnnotationValueFilter.Factory annotationValueFilterFactory,
                          AnnotationRetention annotationRetention,
                          AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy,
                          Implementation.Context.Factory implementationContextFactory,
                          TypeValidation typeValidation,
                          TypePool typePool)
        Creates a new default type writer.
        Parameters:
        instrumentedType - The instrumented type to be created.
        classFileVersion - The class file specified by the user.
        fieldPool - The field 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.
        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.
        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,
                                                    TypeWriter.FieldPool fieldPool,
                                                    TypeAttributeAppender typeAttributeAppender,
                                                    AsmVisitorWrapper asmVisitorWrapper,
                                                    ClassFileVersion classFileVersion,
                                                    AnnotationValueFilter.Factory annotationValueFilterFactory,
                                                    AnnotationRetention annotationRetention,
                                                    AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy,
                                                    Implementation.Context.Factory implementationContextFactory,
                                                    TypeValidation typeValidation,
                                                    TypePool typePool)
        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.
        fieldPool - The field 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.
        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,
                                                        TypeWriter.FieldPool fieldPool,
                                                        TypeAttributeAppender typeAttributeAppender,
                                                        AsmVisitorWrapper asmVisitorWrapper,
                                                        ClassFileVersion classFileVersion,
                                                        AnnotationValueFilter.Factory annotationValueFilterFactory,
                                                        AnnotationRetention annotationRetention,
                                                        AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy,
                                                        Implementation.Context.Factory implementationContextFactory,
                                                        TypeValidation typeValidation,
                                                        TypePool typePool,
                                                        TypeDescription originalType,
                                                        ClassFileLocator classFileLocator)
        Creates a type writer for redefining a type.
        Type Parameters:
        U - A loaded type that the instrumented type guarantees to subclass.
        Parameters:
        methodRegistry - The compiled method registry to use.
        fieldPool - The field 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.
        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,
                                                    TypeWriter.FieldPool fieldPool,
                                                    TypeAttributeAppender typeAttributeAppender,
                                                    AsmVisitorWrapper asmVisitorWrapper,
                                                    ClassFileVersion classFileVersion,
                                                    AnnotationValueFilter.Factory annotationValueFilterFactory,
                                                    AnnotationRetention annotationRetention,
                                                    AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy,
                                                    Implementation.Context.Factory implementationContextFactory,
                                                    TypeValidation typeValidation,
                                                    TypePool typePool,
                                                    TypeDescription originalType,
                                                    ClassFileLocator classFileLocator,
                                                    MethodRebaseResolver methodRebaseResolver)
        Creates a type writer for rebasing a type.
        Type Parameters:
        U - A loaded type that the instrumented type guarantees to subclass.
        Parameters:
        methodRegistry - The compiled method registry to use.
        fieldPool - The field 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.
        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.
      • make

        public DynamicType.Unloaded<S> make​(TypeResolutionStrategy.Resolved typeResolutionStrategy)
        Description copied from interface: TypeWriter
        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.UnresolvedType create​(TypeInitializer typeInitializer)
        Creates an unresolved version of the dynamic type.
        Parameters:
        typeInitializer - The type initializer to use.
        Returns:
        An unresolved type.