Types: add method accessor

This is analogous to the field accessor, but for methods.

Author: ctrueden

src/main/java/org/scijava/util/Types.java

@@ -536,6 +536,41 @@ public static Field field(final Class<?> c, final String name) {
 		return field(c.getSuperclass(), name);
 	}
 
+	/**
+	 * Gets the method with the specified name and argument types, of the given
+	 * class, or superclass thereof.
+	 * <p>
+	 * Unlike {@link Class#getMethod(String, Class[])}, this method will return
+	 * methods of any visibility, not just {@code public}. And unlike
+	 * {@link Class#getDeclaredMethod(String, Class[])}, it will do so
+	 * recursively, returning the first method of the given name and argument
+	 * types from the class's superclass hierarchy.
+	 * </p>
+	 * <p>
+	 * Note that this method does not guarantee that the returned method is
+	 * accessible; if the method is not {@code public}, calling code will need to
+	 * use {@link Method#setAccessible(boolean)} in order to invoke the method.
+	 * </p>
+	 * 
+	 * @param c The class (or subclass thereof) containing the desired method.
+	 * @param name Name of the method.
+	 * @param parameterTypes Types of the method parameters.
+	 * @return The first method with the given name and argument types in the
+	 *         class's superclass hierarchy.
+	 * @throws IllegalArgumentException If the specified class does not contain a
+	 *           method with the given name and argument types.
+	 */
+	public static Method method(final Class<?> c, final String name,
+		final Class<?>... parameterTypes)
+	{
+		if (c == null) throw iae("No such field: " + name);
+		try {
+			return c.getDeclaredMethod(name, parameterTypes);
+		}
+		catch (final NoSuchMethodException exc) {}
+		return method(c.getSuperclass(), name, parameterTypes);
+	}
+
 	/**
 	 * Gets the array class corresponding to the given element type.
 	 * <p>

src/test/java/org/scijava/util/TypesTest.java

@@ -47,6 +47,7 @@
 import java.io.OutputStream;
 import java.io.Serializable;
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.math.BigDecimal;
@@ -373,6 +374,28 @@ public void testField() {
 		assertEquals("T", ((TypeVariable<?>) field.getGenericType()).getName());
 	}
 
+	/** Tests {@link Types#method}. */
+	@Test
+	public void testMethod() {
+		final Method objectMethod = Types.method(Thing.class, "toString");
+		assertSame(Object.class, objectMethod.getDeclaringClass());
+		assertEquals("toString", objectMethod.getName());
+		assertSame(String.class, objectMethod.getReturnType());
+		assertEquals(0, objectMethod.getParameterTypes().length);
+
+		final Method wordsMethod = //
+			Types.method(Words.class, "valueOf", String.class);
+		// NB: What is going on under the hood to make the Enum
+		// subtype Words be the declaring class for the 'valueOf'
+		// method? The compiler must internally override the valueOf
+		// method for each enum type, to narrow the return type...
+		assertSame(Words.class, wordsMethod.getDeclaringClass());
+		assertEquals("valueOf", wordsMethod.getName());
+		assertSame(Words.class, wordsMethod.getReturnType());
+		assertEquals(1, wordsMethod.getParameterTypes().length);
+		assertSame(String.class, wordsMethod.getParameterTypes()[0]);
+	}
+
 	/** Tests {@link Types#array}. */
 	@Test
 	public void testArray() {