org.objectweb.asm.MethodVisitor.visitTypeAnnotation java code examples

public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) {
  return AnnotationVisitorTee.getInstance(mv1.visitTypeAnnotation(typeRef, typePath, desc, visible),
                      mv2.visitTypeAnnotation(typeRef, typePath, desc, visible));
}

public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) {
  return AnnotationVisitorTee.getInstance(mv1.visitTypeAnnotation(typeRef, typePath, desc, visible),
                      mv2.visitTypeAnnotation(typeRef, typePath, desc, visible));
}

/**
 * Visits an annotation on a type in the method signature.
 *
 * @param typeRef a reference to the annotated type. The sort of this type reference must be
 *     {@link TypeReference#METHOD_TYPE_PARAMETER}, {@link
 *     TypeReference#METHOD_TYPE_PARAMETER_BOUND}, {@link TypeReference#METHOD_RETURN}, {@link
 *     TypeReference#METHOD_RECEIVER}, {@link TypeReference#METHOD_FORMAL_PARAMETER} or {@link
 *     TypeReference#THROWS}. See {@link TypeReference}.
 * @param typePath the path to the annotated type argument, wildcard bound, array element type, or
 *     static inner type within 'typeRef'. May be {@literal null} if the annotation targets
 *     'typeRef' as a whole.
 * @param descriptor the class descriptor of the annotation class.
 * @param visible {@literal true} if the annotation is visible at runtime.
 * @return a visitor to visit the annotation values, or {@literal null} if this visitor is not
 *     interested in visiting this annotation.
 */
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 if (api < Opcodes.ASM5) {
  throw new UnsupportedOperationException(REQUIRES_ASM5);
 }
 if (mv != null) {
  return mv.visitTypeAnnotation(typeRef, typePath, descriptor, visible);
 }
 return null;
}

methodVisitor.visitTypeAnnotation(
  context.currentTypeAnnotationTarget,
  context.currentTypeAnnotationTargetPath,
methodVisitor.visitTypeAnnotation(
  context.currentTypeAnnotationTarget,
  context.currentTypeAnnotationTargetPath,

/**
 * Visits an annotation on a type in the method signature.
 *
 * @param typeRef a reference to the annotated type. The sort of this type reference must be
 *     {@link TypeReference#METHOD_TYPE_PARAMETER}, {@link
 *     TypeReference#METHOD_TYPE_PARAMETER_BOUND}, {@link TypeReference#METHOD_RETURN}, {@link
 *     TypeReference#METHOD_RECEIVER}, {@link TypeReference#METHOD_FORMAL_PARAMETER} or {@link
 *     TypeReference#THROWS}. See {@link TypeReference}.
 * @param typePath the path to the annotated type argument, wildcard bound, array element type, or
 *     static inner type within 'typeRef'. May be {@literal null} if the annotation targets
 *     'typeRef' as a whole.
 * @param descriptor the class descriptor of the annotation class.
 * @param visible {@literal true} if the annotation is visible at runtime.
 * @return a visitor to visit the annotation values, or {@literal null} if this visitor is not
 *     interested in visiting this annotation.
 */
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 if (api < Opcodes.ASM5) {
  throw new UnsupportedOperationException(REQUIRES_ASM5);
 }
 if (mv != null) {
  return mv.visitTypeAnnotation(typeRef, typePath, descriptor, visible);
 }
 return null;
}

@Override
public AnnotationVisitor visitTypeAnnotation(final int typeRef,
  final TypePath typePath, final String desc, final boolean visible) {
 fsmCursor.transition("visitTypeAnnotation");
 final AnnotationVisitor annotationVisitor = super.visitTypeAnnotation(
   typeRef, typePath, desc, visible);
 return annotationVisitor; // TODO: add CheckAnnotationVisitorFsm
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 AnnotationVisitor annotationVisitor =
   super.visitTypeAnnotation(typeRef, typePath, remapper.mapDesc(descriptor), visible);
 return annotationVisitor == null
   ? annotationVisitor
   : new AnnotationRemapper(api, annotationVisitor, remapper);
}

@Override
public AnnotationVisitor visitTypeAnnotation(int typeRef,
    TypePath typePath, String desc, boolean visible) {
  Printer p = this.p.visitMethodTypeAnnotation(typeRef, typePath, desc,
      visible);
  AnnotationVisitor av = mv == null ? null : mv.visitTypeAnnotation(
      typeRef, typePath, desc, visible);
  return new TraceAnnotationVisitor(av, p);
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  int typeRef, TypePath typePath, String desc, boolean visible) {
 log.traceEntry("typeRef={} typePath={} desc={} visible={}", typeRef, typePath, desc, desc);
 final AnnotationVisitor annotationVisitor =
   super.visitTypeAnnotation(typeRef, typePath, desc, visible);
 return log.traceExit(annotationVisitor);
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 AnnotationVisitor annotationVisitor =
   super.visitTypeAnnotation(typeRef, typePath, remapper.mapDesc(descriptor), visible);
 return annotationVisitor == null
   ? annotationVisitor
   : new AnnotationRemapper(api, annotationVisitor, remapper);
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 Printer annotationPrinter = p.visitMethodTypeAnnotation(typeRef, typePath, descriptor, visible);
 return new TraceAnnotationVisitor(
   super.visitTypeAnnotation(typeRef, typePath, descriptor, visible), annotationPrinter);
}

@Override
public AnnotationVisitor visitTypeAnnotation(int typeRef,
    TypePath typePath, String desc, boolean visible) {
  AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath,
      remapper.mapDesc(desc), visible);
  return av == null ? av : new AnnotationRemapper(av, remapper);
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 Printer annotationPrinter = p.visitMethodTypeAnnotation(typeRef, typePath, descriptor, visible);
 return new TraceAnnotationVisitor(
   super.visitTypeAnnotation(typeRef, typePath, descriptor, visible), annotationPrinter);
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 AnnotationVisitor annotationVisitor =
   super.visitTypeAnnotation(typeRef, typePath, remapper.mapDesc(descriptor), visible);
 return annotationVisitor == null
   ? annotationVisitor
   : new AnnotationRemapper(api, annotationVisitor, remapper);
}

@Override
public AnnotationVisitor visitTypeAnnotation(int typeRef,
    TypePath typePath, String desc, boolean visible) {
  AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath,
      remapper.mapDesc(desc), visible);
  return av == null ? av : new AnnotationRemapper(av, remapper);
}

@Override
public void begin(final String name, final Attributes attrs) {
 String desc = attrs.getValue("desc");
 boolean visible = Boolean.valueOf(attrs.getValue("visible")).booleanValue();
 int typeRef = Integer.parseInt(attrs.getValue("typeRef"));
 TypePath typePath = TypePath.fromString(attrs.getValue("typePath"));
 Object v = peek();
 if (v instanceof ClassVisitor) {
  push(((ClassVisitor) v).visitTypeAnnotation(typeRef, typePath, desc, visible));
 } else if (v instanceof FieldVisitor) {
  push(((FieldVisitor) v).visitTypeAnnotation(typeRef, typePath, desc, visible));
 } else if (v instanceof MethodVisitor) {
  push(((MethodVisitor) v).visitTypeAnnotation(typeRef, typePath, desc, visible));
 }
}

@Override
public void begin(final String name, final Attributes attrs) {
  String desc = attrs.getValue("desc");
  boolean visible = Boolean.valueOf(attrs.getValue("visible"))
      .booleanValue();
  int typeRef = Integer.parseInt(attrs.getValue("typeRef"));
  TypePath typePath = TypePath.fromString(attrs.getValue("typePath"));
  Object v = peek();
  if (v instanceof ClassVisitor) {
    push(((ClassVisitor) v).visitTypeAnnotation(typeRef, typePath,
        desc, visible));
  } else if (v instanceof FieldVisitor) {
    push(((FieldVisitor) v).visitTypeAnnotation(typeRef, typePath,
        desc, visible));
  } else if (v instanceof MethodVisitor) {
    push(((MethodVisitor) v).visitTypeAnnotation(typeRef, typePath,
        desc, visible));
  }
}

@Override
public AnnotationVisitor visitTypeAnnotation(final int typeRef,
    final TypePath typePath, final String desc, final boolean visible) {
  checkEndMethod();
  int sort = typeRef >>> 24;
  if (sort != TypeReference.METHOD_TYPE_PARAMETER
      && sort != TypeReference.METHOD_TYPE_PARAMETER_BOUND
      && sort != TypeReference.METHOD_RETURN
      && sort != TypeReference.METHOD_RECEIVER
      && sort != TypeReference.METHOD_FORMAL_PARAMETER
      && sort != TypeReference.THROWS) {
    throw new IllegalArgumentException("Invalid type reference sort 0x"
        + Integer.toHexString(sort));
  }
  CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath);
  CheckMethodAdapter.checkDesc(desc, false);
  return new CheckAnnotationAdapter(super.visitTypeAnnotation(typeRef,
      typePath, desc, visible));
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 checkVisitEndNotCalled();
 int sort = new TypeReference(typeRef).getSort();
 if (sort != TypeReference.METHOD_TYPE_PARAMETER
   && sort != TypeReference.METHOD_TYPE_PARAMETER_BOUND
   && sort != TypeReference.METHOD_RETURN
   && sort != TypeReference.METHOD_RECEIVER
   && sort != TypeReference.METHOD_FORMAL_PARAMETER
   && sort != TypeReference.THROWS) {
  throw new IllegalArgumentException(INVALID_TYPE_REFERENCE + Integer.toHexString(sort));
 }
 CheckClassAdapter.checkTypeRef(typeRef);
 CheckMethodAdapter.checkDescriptor(version, descriptor, false);
 return new CheckAnnotationAdapter(
   super.visitTypeAnnotation(typeRef, typePath, descriptor, visible));
}

@Override
public AnnotationVisitor visitTypeAnnotation(
  final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
 checkVisitEndNotCalled();
 int sort = new TypeReference(typeRef).getSort();
 if (sort != TypeReference.METHOD_TYPE_PARAMETER
   && sort != TypeReference.METHOD_TYPE_PARAMETER_BOUND
   && sort != TypeReference.METHOD_RETURN
   && sort != TypeReference.METHOD_RECEIVER
   && sort != TypeReference.METHOD_FORMAL_PARAMETER
   && sort != TypeReference.THROWS) {
  throw new IllegalArgumentException(INVALID_TYPE_REFERENCE + Integer.toHexString(sort));
 }
 CheckClassAdapter.checkTypeRef(typeRef);
 CheckMethodAdapter.checkDescriptor(version, descriptor, false);
 return new CheckAnnotationAdapter(
   super.visitTypeAnnotation(typeRef, typePath, descriptor, visible));
}

Javadoc

Visits an annotation on a type in the method signature.

Popular methods of MethodVisitor

visitMethodInsn
Visits a method instruction. A method instruction is an instruction that invokes a method.
visitInsn
Visits a zero operand instruction.
visitVarInsn
Visits a local variable instruction. A local variable instruction is an instruction that loads or st
visitMaxs
Visits the maximum stack size and the maximum number of local variables of the method.
visitEnd
Visits the end of the method. This method, which is the last one to be called, is used to inform the
visitCode
Starts the visit of the method's code, if any (i.e. non abstract method).
visitFieldInsn
Visits a field instruction. A field instruction is an instruction that loads or stores the value of
visitTypeInsn
Visits a type instruction. A type instruction is an instruction that takes the internal name of a cl
visitLabel
Visits a label. A label designates the instruction that will be visited just after it.
visitLdcInsn
Visits a LDC instruction. Note that new constant types may be added in future versions of the Java V
visitJumpInsn
Visits a jump instruction. A jump instruction is an instruction that may jump to another instruction
visitIntInsn
Visits an instruction with a single int operand.

Popular in Java

Running tasks concurrently on multiple threads
findViewById (Activity)
scheduleAtFixedRate (Timer)
compareTo (BigDecimal)
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
Random (java.util)
This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
UUID (java.util)
UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
HttpServletRequest (javax.servlet.http)
Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ
Top Vim plugins

How to use visitTypeAnnotationmethodin org.objectweb.asm.MethodVisitor

Best Java code snippets using org.objectweb.asm.MethodVisitor.visitTypeAnnotation (Showing top 20 results out of 315)

How to use
visitTypeAnnotation
method
in
org.objectweb.asm.MethodVisitor