Java Code Examples for net.bytebuddy.utility.OpenedClassReader#ASM_API

/**
 * Creates a new modifier adjusting visitor.
 *
 * @param classVisitor      The class visitor to delegate to.
 * @param typeAdjustments   A list of type modifier adjustments to apply.
 * @param fieldAdjustments  A list of field modifier adjustments to apply.
 * @param methodAdjustments A list of method modifier adjustments to apply.
 * @param instrumentedType  The instrumented type.
 * @param fields            A mapping of field names and descriptors to their description.
 * @param methods           A mapping of method names and descriptors to their description.
 */
protected ModifierAdjustingClassVisitor(ClassVisitor classVisitor,
                                        List<Adjustment<TypeDescription>> typeAdjustments,
                                        List<Adjustment<FieldDescription.InDefinedShape>> fieldAdjustments,
                                        List<Adjustment<MethodDescription>> methodAdjustments,
                                        TypeDescription instrumentedType,
                                        Map<String, FieldDescription.InDefinedShape> fields,
                                        Map<String, MethodDescription> methods) {
    super(OpenedClassReader.ASM_API, classVisitor);
    this.typeAdjustments = typeAdjustments;
    this.fieldAdjustments = fieldAdjustments;
    this.methodAdjustments = methodAdjustments;
    this.instrumentedType = instrumentedType;
    this.fields = fields;
    this.methods = methods;
}
 

/**
 * Creates a new member removing class visitor.
 *
 * @param classVisitor  The class visitor to delegate to.
 * @param fieldMatcher  The matcher that determines field removal.
 * @param methodMatcher The matcher that determines method removal.
 * @param fields        A mapping of field names and descriptors to their description.
 * @param methods       A mapping of method names and descriptors to their description.
 */
protected MemberRemovingClassVisitor(ClassVisitor classVisitor,
                                     ElementMatcher.Junction<FieldDescription.InDefinedShape> fieldMatcher,
                                     ElementMatcher.Junction<MethodDescription> methodMatcher,
                                     Map<String, FieldDescription.InDefinedShape> fields,
                                     Map<String, MethodDescription> methods) {
    super(OpenedClassReader.ASM_API, classVisitor);
    this.fieldMatcher = fieldMatcher;
    this.methodMatcher = methodMatcher;
    this.fields = fields;
    this.methods = methods;
}
 

/**
 * Creates a type reference class visitor.
 *
 * @param classVisitor {@code true} if the visitor should throw an exception if a type reference cannot be located.
 * @param strict       {@code true} if the visitor should throw an exception if a type reference cannot be located.
 * @param filter       A filter for excluding types from type reference analysis.
 * @param typePool     The type pool to use for locating types.
 */
protected TypeReferenceClassVisitor(ClassVisitor classVisitor, boolean strict, ElementMatcher<? super TypeDescription> filter, TypePool typePool) {
    super(OpenedClassReader.ASM_API, classVisitor);
    this.typePool = typePool;
    this.strict = strict;
    this.filter = filter;
    observedTypes = new HashSet<String>();
    visitedInnerTypes = new HashSet<String>();
}
 

/**
 * Creates a new field attribute visitor.
 *
 * @param fieldVisitor           The field visitor to apply changes to.
 * @param fieldDescription       The field to add annotations to.
 * @param fieldAttributeAppender The field attribute appender to apply.
 * @param annotationValueFilter  The annotation value filter to apply.
 */
private FieldAttributeVisitor(FieldVisitor fieldVisitor,
                              FieldDescription fieldDescription,
                              FieldAttributeAppender fieldAttributeAppender,
                              AnnotationValueFilter annotationValueFilter) {
    super(OpenedClassReader.ASM_API, fieldVisitor);
    this.fieldDescription = fieldDescription;
    this.fieldAttributeAppender = fieldAttributeAppender;
    this.annotationValueFilter = annotationValueFilter;
}
 

private TypeValidator(ClassVisitor classVisitor, int modifiers,
                      Set<InnerClassAttribute> innerClassAttributes,
                      OuterClassAttribute outerClassAttribute) {
    super(OpenedClassReader.ASM_API, classVisitor);
    this.modifiers = modifiers;
    this.innerClassAttributes = innerClassAttributes;
    this.outerClassAttribute = outerClassAttribute;
}
 

/**
 * Creates a new stack aware method visitor.
 *
 * @param methodVisitor      The method visitor to delegate operations to.
 * @param instrumentedMethod The method description for which this method visitor is applied.
 */
public StackAwareMethodVisitor(MethodVisitor methodVisitor, MethodDescription instrumentedMethod) {
    super(OpenedClassReader.ASM_API, methodVisitor);
    current = new ArrayList<StackSize>();
    sizes = new HashMap<Label, List<StackSize>>();
    freeIndex = instrumentedMethod.getStackSize();
}
 

private TypeModifierExtractor() {
    super(OpenedClassReader.ASM_API);
}
 

private static ClassNode convertToClassNode(InputStream classBytes) throws IOException {
    val result = new ClassNode(OpenedClassReader.ASM_API);
    val reader =  new ClassReader(classBytes);
    reader.accept(result, ClassReader.SKIP_FRAMES);
    return result;
}
 

private MixinClassVisitor(MixinDescription mixin, String className, ClassVisitor classVisitor) {
    super(OpenedClassReader.ASM_API, classVisitor);
    this.mixin = mixin;
    this.type = Type.getObjectType(className);
}
 

MixinInitializer(MethodVisitor mv, int access, String name, String desc, Type typeClass, MixinDescription mixinDescription) {
    super(OpenedClassReader.ASM_API, mv, access, name, desc);
    this.typeClass = typeClass;
    this.mixinDescription = mixinDescription;
}
 

public GenericDisintegrator(ClassVisitor classVisitor) {
    super(OpenedClassReader.ASM_API, classVisitor);
}
 

private ClassFileVersionValidatorClassVisitor(ClassVisitor classVisitor) {
    super(OpenedClassReader.ASM_API, classVisitor);
}
 

private DelegatingMetadataAwareClassVisitor() {
    super(OpenedClassReader.ASM_API, null);
}
 

private AssertionClassVisitor(ClassVisitor classVisitor) {
    super(OpenedClassReader.ASM_API, classVisitor);
}
 

public SerializationClassVisitor(ClassVisitor classVisitor) {
    super(OpenedClassReader.ASM_API, classVisitor);
}
 

/**
 * Creates a new frame padding method visitor.
 *
 * @param methodVisitor The delegate method visitor.
 */
public FramePaddingMethodVisitor(MethodVisitor methodVisitor) {
    super(OpenedClassReader.ASM_API, methodVisitor);
    padding = false;
}
 

/**
 * Creates a new type reference-collecting field visitor.
 *
 * @param fieldVisitor The field visitor to delegate to.
 */
protected TypeReferenceFieldVisitor(FieldVisitor fieldVisitor) {
    super(OpenedClassReader.ASM_API, fieldVisitor);
}
 

/**
 * Creates a new type constant dissolving class visitor.
 *
 * @param classVisitor The underlying class visitor.
 */
protected TypeConstantDissolvingClassVisitor(ClassVisitor classVisitor) {
    super(OpenedClassReader.ASM_API, classVisitor);
}
 

/**
 * Creates a new dispatching visitor.
 *
 * @param classVisitor     The underlying class visitor.
 * @param instrumentedType The instrumented type.
 * @param fields           The instrumented type's declared fields.
 */
protected DispatchingVisitor(ClassVisitor classVisitor, TypeDescription instrumentedType, Map<String, FieldDescription.InDefinedShape> fields) {
    super(OpenedClassReader.ASM_API, classVisitor);
    this.instrumentedType = instrumentedType;
    this.fields = fields;
}
 

/**
 * Creates a new type reference-collecting annotation visitor.
 *
 * @param annotationVisitor The annotation visitor to delegate to.
 */
protected TypeReferenceAnnotationVisitor(AnnotationVisitor annotationVisitor) {
    super(OpenedClassReader.ASM_API, annotationVisitor);
}