Class TypeWriter.Default.ForInlining<U>

  • Type Parameters:
    U - The best known loaded type for the dynamically created type.
    All Implemented Interfaces:
    TypeWriter<U>
    Enclosing class:
    TypeWriter.Default<S>

    public static class TypeWriter.Default.ForInlining<U>
    extends TypeWriter.Default<U>
    A type writer that inlines the created type into an existing class file.
    • Constructor Detail

      • ForInlining

        protected ForInlining​(TypeDescription instrumentedType,
                              ClassFileVersion classFileVersion,
                              TypeWriter.FieldPool fieldPool,
                              MethodRegistry.Prepared methodRegistry,
                              Implementation.Target.Factory implementationTargetFactory,
                              java.util.List<DynamicType> explicitAuxiliaryTypes,
                              FieldList<FieldDescription.InDefinedShape> fields,
                              MethodList<?> methods,
                              MethodList<?> instrumentedMethods,
                              LoadedTypeInitializer loadedTypeInitializer,
                              TypeInitializer typeInitializer,
                              TypeAttributeAppender typeAttributeAppender,
                              AsmVisitorWrapper asmVisitorWrapper,
                              AnnotationValueFilter.Factory annotationValueFilterFactory,
                              AnnotationRetention annotationRetention,
                              AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy,
                              Implementation.Context.Factory implementationContextFactory,
                              TypeValidation typeValidation,
                              TypePool typePool,
                              TypeDescription originalType,
                              ClassFileLocator classFileLocator,
                              MethodRebaseResolver methodRebaseResolver)
        Creates a new default type writer for creating a new type that is not based on an existing class file.
        Parameters:
        instrumentedType - The instrumented type to be created.
        classFileVersion - The class file version to define auxiliary types in.
        fieldPool - The field pool to use.
        methodRegistry - The method registry to use.
        implementationTargetFactory - The implementation target factory to use.
        explicitAuxiliaryTypes - The explicit auxiliary types to add to the created type.
        fields - The instrumented type's declared fields.
        methods - The instrumented type's declared or 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.
        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 methods.