Merge matching and type utils

Treiblesschorle · ctrueden · commit 071986825005 · 2019-04-18T12:16:31.000-05:00
diff --git a/src/main/java/org/scijava/ops/matcher/DefaultOpTypeMatchingService.java b/src/main/java/org/scijava/ops/matcher/DefaultOpTypeMatchingService.java
@@ -299,7 +299,7 @@ private int findCastLevels(final OpCandidate candidate) {
 		for (final Member<?> member : OpUtils.inputs(candidate)) {
 			final Class<?> type = member.getRawType();
 			if (paddedArgs[i] != null) {
-				final int currLevel = OpMatchingUtil.findCastLevels(type, OpMatchingUtil.getClass(paddedArgs[i]));
+				final int currLevel = MatchingUtils.findCastLevels(type, MatchingUtils.getClass(paddedArgs[i]));
 				if (currLevel < 0)
 					return -1;
 				level += currLevel;
diff --git a/src/main/java/org/scijava/ops/matcher/MatchingUtils.java b/src/main/java/org/scijava/ops/matcher/MatchingUtils.java
@@ -30,21 +30,26 @@
  * #L%
  */
 
-package org.scijava.util;
+package org.scijava.ops.matcher;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.lang.reflect.WildcardType;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 
+import org.scijava.ops.types.Nil;
+import org.scijava.util.Types;
+
 import com.google.common.base.Objects;
 
-public final class TypeUtils {
+public final class MatchingUtils {
 
-	private TypeUtils() {
+	private MatchingUtils() {
 		// prevent instantiation of utility class
 	}
 
@@ -297,4 +302,68 @@ public static Type[] getParams(Class<?> subType, Class<?> superErasure) {
 		}
 		return new Type[0];
 	}
+	
+	/**
+	 * Gets the "useful" class information carries on the given object, which
+	 * depends on the actual type of the object.
+	 */
+	public static Class<?> getClass(final Object obj) {
+		if (obj == null)
+			return null;
+		if (obj instanceof Nil)
+			return getClass(((Nil<?>) obj).getType());
+		if (obj instanceof Class)
+			return (Class<?>) obj;
+		if (obj instanceof ParameterizedType)
+			return (Class<?>) ((ParameterizedType) obj).getRawType();
+		return obj.getClass();
+	}
+
+	/**
+	 * Finds the levels of casting between <code>origin</code> and
+	 * <code>dest</code>. Returns 0 if dest and origin are the same. Returns -1
+	 * if dest is not assignable from origin.
+	 */
+	public static int findCastLevels(final Class<?> dest, final Class<?> origin) {
+		if (dest.equals(origin))
+			return 0;
+
+		int level = 1;
+		Class<?> currType = origin;
+		// BFS if dest is an interface
+		if (dest.isInterface()) {
+			final HashSet<String> seen = new HashSet<>();
+			final ArrayList<Type> currIfaces = new ArrayList<>(Arrays.asList(currType.getGenericInterfaces()));
+			do {
+				final ArrayList<Type> nextIfaces = new ArrayList<>();
+				for (final Type iface : currIfaces) {
+					if (seen.contains(iface.getTypeName()))
+						continue;
+
+					final Class<?> cls = getClass(iface);
+					if (cls.equals(dest))
+						return level;
+					seen.add(iface.getTypeName());
+					nextIfaces.addAll(Arrays.asList(cls.getGenericInterfaces()));
+				}
+				currIfaces.clear();
+				currIfaces.addAll(nextIfaces);
+				if (currType.getSuperclass() != null) {
+					currType = currType.getSuperclass();
+					currIfaces.addAll(Arrays.asList(currType.getGenericInterfaces()));
+				}
+				level++;
+			} while (!currIfaces.isEmpty() || currType.getSuperclass() != null);
+		}
+		// otherwise dest is a class, so search the list of ancestors
+		else {
+			while (currType.getSuperclass() != null) {
+				currType = currType.getSuperclass();
+				if (currType.equals(dest))
+					return level;
+				level++;
+			}
+		}
+		return -1;
+	}
 }
diff --git a/src/main/java/org/scijava/ops/matcher/OpMatchingUtil.java b/src/main/java/org/scijava/ops/matcher/OpMatchingUtil.java
diff --git a/src/main/java/org/scijava/ops/matcher/OpRef.java b/src/main/java/org/scijava/ops/matcher/OpRef.java
@@ -35,7 +35,6 @@
 import java.util.Objects;
 
 import org.scijava.ops.core.Op;
-import org.scijava.util.TypeUtils;
 import org.scijava.util.Types;
 
 /**
@@ -138,7 +137,7 @@ public boolean typesMatch(final Class<?> opClass) {
 			return true;
 		for (Type t : types) {
 			if(t instanceof ParameterizedType) {
-				if (!TypeUtils.checkGenericAssignability(opClass, (ParameterizedType) t)) {
+				if (!MatchingUtils.checkGenericAssignability(opClass, (ParameterizedType) t)) {
 					return false;
 				}
 			} else {
diff --git a/src/test/java/org/scijava/ops/util/MatchingUtilsTest.java b/src/test/java/org/scijava/ops/util/MatchingUtilsTest.java
@@ -39,11 +39,11 @@
 import java.util.function.Supplier;
 
 import org.junit.Test;
+import org.scijava.ops.matcher.MatchingUtils;
 import org.scijava.ops.types.Nil;
-import org.scijava.util.TypeUtils;
 import org.scijava.util.Types;
 
-public class TypeUtilsTest {
+public class MatchingUtilsTest {
 
 	private void assertAll(Class<?> from, boolean condition, Nil<?>... tos) {
 		for (Nil<?> to : tos) {
@@ -54,7 +54,7 @@ private void assertAll(Class<?> from, boolean condition, Nil<?>... tos) {
 	private void assertAll(Class<?> from, boolean condition, Type... tos) {
 		for (Type to : tos) {
 			if (to instanceof ParameterizedType) {
-				assertTrue(TypeUtils.checkGenericAssignability(from, (ParameterizedType) to) == condition);
+				assertTrue(MatchingUtils.checkGenericAssignability(from, (ParameterizedType) to) == condition);
 			} else {
 				assertTrue(Types.isAssignable(from, to) == condition);
 			}
@@ -392,12 +392,12 @@ abstract class Wildcards implements Function<List<? extends Number>, List<? exte
 
 	@Test(expected = NullPointerException.class)
 	public void testIsAssignableNullToNull() {
-		TypeUtils.checkGenericAssignability(null, null);
+		MatchingUtils.checkGenericAssignability(null, null);
 	}
 
 	@Test(expected = NullPointerException.class)
 	public void testIsAssignableClassToNull() {
-		TypeUtils.checkGenericAssignability(Object.class, null);
+		MatchingUtils.checkGenericAssignability(Object.class, null);
 	}
 
 	@Test
