jodd.proxetta.MethodInfo.getArgumentsCount java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 BufferedReader b =InputStream in;new BufferedReader(new InputStreamReader(in))
Reader in;new BufferedReader(in)
File file;new BufferedReader(new FileReader(file))
Smart code suggestions by Tabnine
}

/**
 * Returns <code>true</code> if method has only one argument.
 */
default boolean hasOneArgument() {
  return getArgumentsCount() == 1;
}

/**
 * Returns <code>true</code> if method has no argument.
 */
default boolean hasNoArguments() {
  return getArgumentsCount() == 0;
}

/**
 * Visits replacement code for {@link ProxyTarget#argumentsCount()}.
 */
public static void argumentsCount(final MethodVisitor mv, final MethodInfo methodInfo) {
  int argsCount = methodInfo.getArgumentsCount();
  pushInt(mv, argsCount);
}

/**
 * Loads all method arguments before INVOKEVIRTUAL call.
 */
public static void loadVirtualMethodArguments(final MethodVisitor mv, final MethodInfo methodInfo) {
  for (int i = 1; i <= methodInfo.getArgumentsCount(); i++) {
    loadMethodArgument(mv, methodInfo, i);
  }
}

/**
 * Loads all method arguments before INVOKESTATIC call.
 */
public static void loadStaticMethodArguments(final MethodVisitor mv, final MethodInfo methodInfo) {
  for (int i = 0; i < methodInfo.getArgumentsCount(); i++) {
    loadMethodArgument(mv, methodInfo, i);
  }
}

/**
 * Validates argument index.
 */
public static void checkArgumentIndex(final MethodInfo methodInfo, final int argIndex) {
  if ((argIndex < 1) || (argIndex > methodInfo.getArgumentsCount())) {
    throw new ProxettaException("Invalid argument index: " + argIndex);
  }
}

/**
 * Loads all method arguments before INVOKESPECIAL call.
 */
public static void loadSpecialMethodArguments(final MethodVisitor mv, final MethodInfo methodInfo) {
  mv.visitVarInsn(ALOAD, 0);
  for (int i = 1; i <= methodInfo.getArgumentsCount(); i++) {
    loadMethodArgument(mv, methodInfo, i);
  }
}

/**
 * Visits replacement code for {@link ProxyTarget#createArgumentsArray()}.
 */
public static void createArgumentsArray(final MethodVisitor mv, final MethodInfo methodInfo) {
  int argsCount = methodInfo.getArgumentsCount();
  pushInt(mv, argsCount);
  mv.visitTypeInsn(ANEWARRAY, AsmUtil.SIGNATURE_JAVA_LANG_OBJECT);
  for (int i = 0; i < argsCount; i++) {
    mv.visitInsn(DUP);
    pushInt(mv, i);
    loadMethodArgumentAsObject(mv, methodInfo, i + 1);
    mv.visitInsn(AASTORE);
  }
}

/**
 * Visits replacement code for {@link ProxyTarget#createArgumentsClassArray()}.
 */
public static void createArgumentsClassArray(final MethodVisitor mv, final MethodInfo methodInfo) {
  int argsCount = methodInfo.getArgumentsCount();
  pushInt(mv, argsCount);
  mv.visitTypeInsn(ANEWARRAY, AsmUtil.SIGNATURE_JAVA_LANG_CLASS);
  for (int i = 0; i < argsCount; i++) {
    mv.visitInsn(DUP);
    pushInt(mv, i);
    loadMethodArgumentClass(mv, methodInfo, i + 1);
    mv.visitInsn(AASTORE);
  }
}

/**
 * Returns {@link WrapperProxetta} used for building loggable prepared statements.
 * Initializes proxetta when called for the first time.
 */
protected BaseLoggableFactory(final Class<T> targetClass) {
  this.targetClass = targetClass;
  this.proxetta = Proxetta.wrapperProxetta().withAspect(ProxyAspect.of(LoggableAdvice.class, methodInfo -> {
    int argumentsCount = methodInfo.getArgumentsCount();
    char argumentType = 0;
    if (argumentsCount >= 1) {
      argumentType = methodInfo.getArgument(1).getOpcode();
    }
    return
      methodInfo.getReturnType().getOpcode() == 'V' &&			// void-returning method
        argumentType == 'I' &&									// first argument type
        methodInfo.isPublicMethod() &&
        methodInfo.getMethodName().startsWith("set") &&			// set*
        (argumentsCount == 2 || argumentsCount == 3);			// number of arguments
  }));
}

@Test
void testMethodSignature8() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M8.class);
  assertEquals(0, msv.getArgumentsCount());
  assertEquals(CLASS_SIGNATURE + "$M8", msv.getClassname());
  assertEquals("macka#()V", msv.getCleanSignature());
  assertEquals("()void", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M8", msv.getDeclaredClassName());
  assertEquals("()V", msv.getDescription());
  assertEquals("java/io/IOException,java/lang/NullPointerException", msv.getExceptionsAsString());
  assertEquals("macka", msv.getMethodName());
}

@Test
void testMethodSignature10() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M10.class);
  assertEquals(2, msv.getArgumentsCount());
  assertEquals(0, msv.getArgument(1).getAnnotations().length);
  assertEquals(1, msv.getArgument(2).getAnnotations().length);
  assertEquals("jodd.proxetta.fixtures.data.FooAnn", msv.getArgument(2).getAnnotations()[0].getAnnotationClassname());
  assertEquals("macka", msv.getMethodName());
  assertEquals(1, msv.getAnnotations().length);
  assertEquals("jodd.proxetta.fixtures.data.FooAnn", msv.getAnnotations()[0].getAnnotationClassname());
}

@Test
void testMethodSignature9() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M9.class);
  assertEquals(1, msv.getArgumentsCount());
  assertEquals("java.lang.String[]", msv.getArgument(1).getType());
  assertEquals("[Ljava/lang/String;", msv.getArgument(1).getName());
  assertEquals("[Ljava/lang/String;", msv.getArgument(1).getRawName());
  assertEquals('[', msv.getArgument(1).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M9", msv.getClassname());
  assertEquals("main#([Ljava/lang/String;)V", msv.getCleanSignature());
  assertEquals("(java.lang.String[])void", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M9", msv.getDeclaredClassName());
  assertEquals("([Ljava/lang/String;)V", msv.getDescription());
  assertEquals("main", msv.getMethodName());
}

@Test
void testMethodSignature1() throws IOException {
  MethodInfo mi = getMethodSignatureForSingleMethod(M1.class);
  assertEquals(0, mi.getArgumentsCount());
  assertEquals(CLASS_SIGNATURE + "$M1", mi.getClassname());
  assertEquals("macka#()V", mi.getCleanSignature());
  assertEquals("()void", mi.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M1", mi.getDeclaredClassName());
  assertEquals("()V", mi.getDescription());
  assertNull(mi.getExceptions());
  assertEquals("macka", mi.getMethodName());
  assertEquals('V', mi.getReturnType().getOpcode());
  assertEquals("void", mi.getReturnType().getType());
  assertEquals("V", mi.getReturnType().getName());
  assertEquals("V", mi.getReturnType().getRawName());
}

@Test
void testMethodSignature11() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M11.class);
  assertEquals(1, msv.getArgumentsCount());
  assertEquals("java.util.Set<java.util.List<java.util.Map<java.lang.String, java.lang.Object>>>", msv.getArgument(1).getType());
  assertEquals("Ljava/util/Set;", msv.getArgument(1).getName());
  assertEquals("Ljava/util/Set;", msv.getArgument(1).getRawName());
  assertEquals('L', msv.getArgument(1).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M11", msv.getClassname());
  assertEquals("macka#(Ljava/util/Set;)Ljava/util/List;", msv.getCleanSignature());
  assertEquals("(java.util.Set<java.util.List<java.util.Map<java.lang.String, java.lang.Object>>>)java.util.List<java.util.Map<java.lang.String, java.lang.Object>>", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M11", msv.getDeclaredClassName());
  assertEquals("(Ljava/util/Set;)Ljava/util/List;", msv.getDescription());
  assertNull(msv.getExceptions());
  assertEquals("macka", msv.getMethodName());
  assertEquals('L', msv.getReturnType().getOpcode());
  assertEquals("java.util.List<java.util.Map<java.lang.String, java.lang.Object>>", msv.getReturnType().getType());
  assertEquals("Ljava/util/List;", msv.getReturnType().getName());
  assertEquals("Ljava/util/List;", msv.getReturnType().getRawName());
}

@Test
void testMethodSignature12() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M12.class);
  assertEquals(1, msv.getArgumentsCount());
  assertEquals(CLASS_NAME + "$Tupel<java.util.List<java.lang.Integer>, java.lang.Integer>", msv.getArgument(1).getType());
  assertEquals(L_CLASS_SIGNATURE + "$Tupel;", msv.getArgument(1).getName());
  assertEquals(L_CLASS_SIGNATURE + "$Tupel;", msv.getArgument(1).getRawName());
  assertEquals('L', msv.getArgument(1).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M12", msv.getClassname());
  assertEquals("macka#(" + L_CLASS_SIGNATURE + "$Tupel;)Ljava/util/Map;", msv.getCleanSignature());
  assertEquals("(" + CLASS_NAME + "$Tupel<java.util.List<java.lang.Integer>, java.lang.Integer>)java.util.Map<java.util.Map<java.util.Set<java.lang.Integer>, java.lang.Long>, java.lang.Byte>", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M12", msv.getDeclaredClassName());
  assertEquals("(" + L_CLASS_SIGNATURE + "$Tupel;)Ljava/util/Map;", msv.getDescription());
  assertNull(msv.getExceptions());
  assertEquals("macka", msv.getMethodName());
  assertEquals('L', msv.getReturnType().getOpcode());
  assertEquals("java.util.Map<java.util.Map<java.util.Set<java.lang.Integer>, java.lang.Long>, java.lang.Byte>", msv.getReturnType().getType());
  assertEquals("Ljava/util/Map;", msv.getReturnType().getName());
  assertEquals("Ljava/util/Map;", msv.getReturnType().getRawName());
}

@Test
void testMethodSignature3() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M3.class);
  assertEquals(2, msv.getArgumentsCount());
  assertEquals("java.lang.Long", msv.getArgument(1).getType());
  assertEquals("L" + SIGNATURE_JAVA_LANG_LONG + ";", msv.getArgument(1).getName());
  assertEquals("L" + SIGNATURE_JAVA_LANG_LONG + ";", msv.getArgument(1).getRawName());
  assertEquals('L', msv.getArgument(1).getOpcode());
  assertEquals("java.lang.Double", msv.getArgument(2).getType());
  assertEquals("L" + SIGNATURE_JAVA_LANG_DOUBLE + ";", msv.getArgument(2).getName());
  assertEquals("L" + SIGNATURE_JAVA_LANG_DOUBLE + ";", msv.getArgument(2).getRawName());
  assertEquals('L', msv.getArgument(2).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M3", msv.getClassname());
  assertEquals("macka#(L" + SIGNATURE_JAVA_LANG_LONG + ";L" + SIGNATURE_JAVA_LANG_DOUBLE + ";)L" + SIGNATURE_JAVA_LANG_INTEGER + ";", msv.getCleanSignature());
  assertEquals("(java.lang.Long, java.lang.Double)java.lang.Integer", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M3", msv.getDeclaredClassName());
  assertEquals("(Ljava/lang/Long;Ljava/lang/Double;)Ljava/lang/Integer;", msv.getDescription());
  assertNull(msv.getExceptions());
  assertEquals("macka", msv.getMethodName());
  assertEquals('L', msv.getReturnType().getOpcode());
  assertEquals("java.lang.Integer", msv.getReturnType().getType());
  assertEquals("Ljava/lang/Integer;", msv.getReturnType().getName());
  assertEquals("Ljava/lang/Integer;", msv.getReturnType().getRawName());
}

@Test
void testMethodSignature2() throws IOException {
  MethodInfo mi = getMethodSignatureForSingleMethod(M2.class);
  assertEquals(2, mi.getArgumentsCount());
  assertEquals("long", mi.getArgument(1).getType());
  assertEquals("J", mi.getArgument(1).getName());
  assertEquals("J", mi.getArgument(1).getRawName());
  assertEquals('J', mi.getArgument(1).getOpcode());
  assertEquals("double", mi.getArgument(2).getType());
  assertEquals("D", mi.getArgument(2).getName());
  assertEquals("D", mi.getArgument(2).getRawName());
  assertEquals('D', mi.getArgument(2).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M2", mi.getClassname());
  assertEquals("macka#(JD)I", mi.getCleanSignature());
  assertEquals("(long, double)int", mi.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M2", mi.getDeclaredClassName());
  assertEquals("(JD)I", mi.getDescription());
  assertNull(mi.getExceptions());
  assertEquals("macka", mi.getMethodName());
  assertEquals('I', mi.getReturnType().getOpcode());
  assertEquals("int", mi.getReturnType().getType());
  assertEquals("I", mi.getReturnType().getName());
  assertEquals("I", mi.getReturnType().getRawName());
}

@Test
void testMethodSignature5() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M5.class);
  assertEquals(2, msv.getArgumentsCount());
  assertEquals("java.util.Set<Gen>", msv.getArgument(1).getType());
  assertEquals("Ljava/util/Set;", msv.getArgument(1).getName());
  assertEquals("Ljava/util/Set;", msv.getArgument(1).getRawName());
  assertEquals('L', msv.getArgument(1).getOpcode());
  assertEquals("T[]", msv.getArgument(2).getType());
  assertEquals("[T", msv.getArgument(2).getName());
  assertEquals("[Ljava/lang/Object;", msv.getArgument(2).getRawName());
  assertEquals('[', msv.getArgument(2).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M5", msv.getClassname());
  assertEquals("macka#(Ljava/util/Set;[Ljava/lang/Object;)Ljava/util/List;", msv.getCleanSignature());
  assertEquals("(java.util.Set<Gen>, T[])java.util.List<Gen>", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M5", msv.getDeclaredClassName());
  assertEquals("(Ljava/util/Set;[Ljava/lang/Object;)Ljava/util/List;", msv.getDescription());
  assertNull(msv.getExceptions());
  assertEquals("macka", msv.getMethodName());
  assertEquals('L', msv.getReturnType().getOpcode());
  assertEquals("java.util.List<Gen>", msv.getReturnType().getType());
  assertEquals("Ljava/util/List;", msv.getReturnType().getName());
  assertEquals("Ljava/util/List;", msv.getReturnType().getRawName());
}

@Test
void testMethodSignature4() throws IOException {
  MethodInfo msv = getMethodSignatureForSingleMethod(M4.class);
  assertEquals(2, msv.getArgumentsCount());
  assertEquals("java.lang.Long[]", msv.getArgument(1).getType());
  assertEquals("[L" + SIGNATURE_JAVA_LANG_LONG + ";", msv.getArgument(1).getName());
  assertEquals("[L" + SIGNATURE_JAVA_LANG_LONG + ";", msv.getArgument(1).getRawName());
  assertEquals('[', msv.getArgument(1).getOpcode());
  assertEquals("double[]", msv.getArgument(2).getType());
  assertEquals("[D", msv.getArgument(2).getName());
  assertEquals("[D", msv.getArgument(2).getRawName());
  assertEquals('[', msv.getArgument(2).getOpcode());
  assertEquals(CLASS_SIGNATURE + "$M4", msv.getClassname());
  assertEquals("macka#([L" + SIGNATURE_JAVA_LANG_LONG + ";[D)[" + L_CLASS_SIGNATURE + "$M4;", msv.getCleanSignature());
  assertEquals("(java.lang.Long[], double[])jodd.proxetta.MethodSignatureVisitorTest$M4[]", msv.getDeclaration());
  assertEquals(CLASS_SIGNATURE + "$M4", msv.getDeclaredClassName());
  assertEquals("([Ljava/lang/Long;[D)[Ljodd/proxetta/MethodSignatureVisitorTest$M4;", msv.getDescription());
  assertNull(msv.getExceptions());
  assertEquals("macka", msv.getMethodName());
  assertEquals('[', msv.getReturnType().getOpcode());
  assertEquals("jodd.proxetta.MethodSignatureVisitorTest$M4[]", msv.getReturnType().getType());
  assertEquals("[Ljodd/proxetta/MethodSignatureVisitorTest$M4;", msv.getReturnType().getName());
  assertEquals("[Ljodd/proxetta/MethodSignatureVisitorTest$M4;", msv.getReturnType().getRawName());
}

Javadoc

Returns the number of methods arguments.

Popular methods of MethodInfo

getMethodName
Returns method name.
getReturnType
Returns return TypeInfo.
getArgument
Returns methods argument (1-indexed).
isPublicMethod
Returns true if method is public.
getAnnotations
Returns annotation infos, if there is any.
getClassname
Returns bytecode-like class name.
getDeclaredClassName
Returns declared class name for inner methods or #getClassname() for top-level methods.
getSignature
Returns java-like method signature.
isTopLevelMethod
Returns true if method is declared in top-level class.
getAccessFlags
Returns methods access flags.
getClassInfo
Returns target jodd.proxetta.ClassInfo.
getDescription
Returns bytecode-like method description.

Popular in Java

Finding current android device location
findViewById (Activity)
setScale (BigDecimal)
scheduleAtFixedRate (ScheduledExecutorService)
FileInputStream (java.io)
An input stream that reads bytes from a file. File file = ...finally if (in != null) in.clos
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
Hashtable (java.util)
A plug-in replacement for JDK1.5 java.util.Hashtable. This version is based on org.cliffc.high_scale
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
Logger (org.apache.log4j)
This is the central class in the log4j package. Most logging operations, except configuration, are d
Project (org.apache.tools.ant)
Central representation of an Ant project. This class defines an Ant project with all of its targets,

How to use getArgumentsCountmethodin jodd.proxetta.MethodInfo

Best Java code snippets using jodd.proxetta.MethodInfo.getArgumentsCount (Showing top 20 results out of 315)

How to use
getArgumentsCount
method
in
jodd.proxetta.MethodInfo