Rename satisfies to isApplicable to match with java naming

Treiblesschorle · ctrueden · commit dd29cf82b806 · 2019-04-18T12:16:31.000-05:00
diff --git a/src/main/java/org/scijava/ops/base/DefaultOpTypeMatchingService.java b/src/main/java/org/scijava/ops/base/DefaultOpTypeMatchingService.java
@@ -148,7 +148,7 @@ public boolean typesMatch(final OpCandidate candidate) {
 			return false;
 		}
 
-		int conflictingIndex = Types.satisfies(refArgTypes, candidateArgTypes);
+		int conflictingIndex = Types.isApplicable(refArgTypes, candidateArgTypes);
 		if (conflictingIndex != -1) {
 			final Type to = refArgTypes[conflictingIndex];
 			final Type from = candidateArgTypes[conflictingIndex];
@@ -342,7 +342,7 @@ private boolean outputsMatch(final OpCandidate candidate) {
 			return false;
 		}
 
-		int conflictingIndex = Types.satisfies(candidateOutTypes, refOutTypes);
+		int conflictingIndex = Types.isApplicable(candidateOutTypes, refOutTypes);
 		if (conflictingIndex != -1) {
 			final Type to = refOutTypes[conflictingIndex];
 			final Type from = candidateOutTypes[conflictingIndex];
diff --git a/src/main/java/org/scijava/ops/base/OpRef.java b/src/main/java/org/scijava/ops/base/OpRef.java
@@ -131,7 +131,7 @@ public String getLabel() {
 
 	/**
 	 * Determines whether the specified type satisfies the op's required types
-	 * using {@link Types#satisfies(Type[], Type[])}.
+	 * using {@link Types#isApplicable(Type[], Type[])}.
 	 */
 	public boolean typesMatch(final Class<?> opClass) {
 		if (types == null)
diff --git a/src/main/java/org/scijava/util/TypeUtils.java b/src/main/java/org/scijava/util/TypeUtils.java
@@ -117,8 +117,8 @@ private TypeUtils() {
 	 * </ul>
 	 * 
 	 * @param src
-	 *            raw type representing parameterized of which assignment should
-	 *            be checked
+	 *            raw type representing the parameterized type of which
+	 *            assignment should be checked
 	 * @param dest
 	 *            the parameterized type for which assignment should be checked
 	 *            to
@@ -222,19 +222,27 @@ private static void inferTypeVariables(Type[] types, Type[] inferFrom, Map<TypeV
 					}
 				}
 
-				// Bounds could also contain type vars, hence possibly go into recursion
+				// Bounds could also contain type vars, hence possibly go into
+				// recursion
 				for (Type bound : varType.getBounds()) {
 					if (bound instanceof TypeVariable && typeAssigns.get((TypeVariable<?>) bound) != null) {
-						// If the bound of the current var (let's call it A) to infer is also a var (let's call it B):
-						// If we already encountered B, we check if the current type to infer from is assignable to 
-						// the already inferred type for B. In this case we do not require equality as  one var is 
-						// bounded by another and it is not the same. E.g.  assume we want to infer the types of vars:
-						// 		A extends Number, B extends A
+						// If the bound of the current var (let's call it A) to
+						// infer is also a var (let's call it B):
+						// If we already encountered B, we check if the current
+						// type to infer from is assignable to
+						// the already inferred type for B. In this case we do
+						// not require equality as one var is
+						// bounded by another and it is not the same. E.g.
+						// assume we want to infer the types of vars:
+						// A extends Number, B extends A
 						// From types:
-						// 		Number, Double
-						// First A is bound to Number, next B to Double. Then we check the bounds for B. We encounter A,
-						// for which we already inferred Number. Hence, it suffices to check whether Double can be assigned
-						// to Number, it does not have to be equal as it is just a transitive bound for B.
+						// Number, Double
+						// First A is bound to Number, next B to Double. Then we
+						// check the bounds for B. We encounter A,
+						// for which we already inferred Number. Hence, it
+						// suffices to check whether Double can be assigned
+						// to Number, it does not have to be equal as it is just
+						// a transitive bound for B.
 						Type typeAssignForBound = typeAssigns.get((TypeVariable<?>) bound);
 						if (!Types.isAssignable(from, typeAssignForBound)) {
 							throw new TypeInferenceException();
@@ -260,7 +268,7 @@ private static void inferTypeVariables(Type[] types, Type[] inferFrom, Map<TypeV
 			}
 		}
 		// Check if the inferred types satisfy their bounds
-		if (!Types.satisfies(typeAssigns)) {
+		if (!Types.typesSatisfyVariables(typeAssigns)) {
 			throw new TypeInferenceException();
 		}
 	}
diff --git a/src/main/java/org/scijava/util/Types.java b/src/main/java/org/scijava/util/Types.java
@@ -793,14 +793,14 @@ public static boolean isInstance(final Object obj, final Class<?> dest) {
 	 * @return -1 if the args satisfy the params, otherwise the index of the arg
 	 *         that does not satisfy its parameter.
 	 */
-	public static int satisfies(final Type[] args, final Type[] params) {
+	public static int isApplicable(final Type[] args, final Type[] params) {
 		// create a HashMap to monitor the restrictions of the type variables.
 		final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds = new HashMap<>();
 
-		return satisfies(args, params, typeBounds);
+		return isApplicable(args, params, typeBounds);
 	}
 
-	public static int satisfies(final Type[] args, final Type[] params,
+	public static int isApplicable(final Type[] args, final Type[] params,
 		final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds)
 	{
 		if (args.length != params.length) {
@@ -811,21 +811,21 @@ public static int satisfies(final Type[] args, final Type[] params,
 			Type arg = args[i];
 			Type param = params[i];
 			// First, check raw type assignability.
-			if (!satisfiesRawTypes(arg, param)) return i;
+			if (!isApplicableToRawTypes(arg, param)) return i;
 
 			if (param instanceof ParameterizedType) {
-				if (!satisfiesParameterizedTypes(arg, (ParameterizedType) param,
+				if (!isApplicableToParameterizedTypes(arg, (ParameterizedType) param,
 					typeBounds)) return i;
 			}
 			else if (param instanceof TypeVariable) {
-				if (!satisfiesTypeVariable(arg, (TypeVariable<?>) param,
+				if (!isApplicableToTypeVariable(arg, (TypeVariable<?>) param,
 					typeBounds)) return i;
 			}
 			else if (param instanceof WildcardType) {
-				if (!satisfiesWildcardType(arg, (WildcardType) param)) return i;
+				if (!isApplicableToWildcardType(arg, (WildcardType) param)) return i;
 			}
 			else if (param instanceof GenericArrayType) {
-				if (!satisfiesGenericArrayType(arg, (GenericArrayType) param,
+				if (!isApplicableToGenericArrayType(arg, (GenericArrayType) param,
 					typeBounds)) return i;
 			}
 			final Type t = TypeToken.of(param).resolveType(arg).getType();
@@ -834,13 +834,13 @@ else if (param instanceof GenericArrayType) {
 		return -1;
 	}
 
-	public static boolean satisfies(
+	public static boolean typesSatisfyVariables(
 		final Map<TypeVariable<?>, Type> typeVarAssigns)
 	{
 		return TypeUtils.typesSatisfyVariables(typeVarAssigns);
 	}
 
-	private static boolean satisfiesRawTypes(final Type arg, final Type param) {
+	private static boolean isApplicableToRawTypes(final Type arg, final Type param) {
 		final List<Class<?>> srcClasses = Types.raws(arg);
 		final List<Class<?>> destClasses = Types.raws(param);
 		for (final Class<?> destClass : destClasses) {
@@ -853,7 +853,7 @@ private static boolean satisfiesRawTypes(final Type arg, final Type param) {
 		return true;
 	}
 
-	private static boolean satisfiesParameterizedTypes(final Type arg,
+	private static boolean isApplicableToParameterizedTypes(final Type arg,
 		final ParameterizedType param,
 		final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds)
 	{
@@ -883,15 +883,15 @@ private static boolean satisfiesParameterizedTypes(final Type arg,
 			if (destType instanceof TypeVariable<?>) {
 				final Type srcType = srcTypes[i];
 				final TypeVariable<?> destTypeVar = (TypeVariable<?>) destType;
-				if (!satisfiesTypeParameter(srcType, destTypeVar, typeBounds))
+				if (!isApplicableToTypeParameter(srcType, destTypeVar, typeBounds))
 					return false;
 				ignoredIndices.add(i);
 			}
 		}
 		srcTypes = filterIndices(srcTypes, ignoredIndices);
 		destTypes = filterIndices(destTypes, ignoredIndices);
 		// recursively run satisfies on these arrays
-		return satisfies(srcTypes, destTypes, typeBounds) == -1;
+		return isApplicable(srcTypes, destTypes, typeBounds) == -1;
 	}
 	
 	/**
@@ -909,7 +909,7 @@ private static boolean satisfiesParameterizedTypes(final Type arg,
 	 * @return {@code boolean} - true if the replacement of {@code param} with
 	 *         {@code arg} is allowed.
 	 */
-	private static boolean satisfiesTypeParameter(final Type arg,
+	private static boolean isApplicableToTypeParameter(final Type arg,
 		final TypeVariable<?> param,
 		final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds)
 	{
@@ -928,11 +928,11 @@ private static boolean satisfiesTypeParameter(final Type arg,
 		// if the type variable refers to some parameterized type (e.g. T extends
 		// List<?>), call satisfiesTypeParameters on the bounds of param that
 		// are ParameterizedTypes.
-		if(!satisfiesTypeVariableBounds(arg, param, typeBounds)) return false;
+		if(!isApplicableToTypeVariableBounds(arg, param, typeBounds)) return false;
 		return true;
 	}
 
-	private static boolean satisfiesTypeVariable(final Type arg,
+	private static boolean isApplicableToTypeVariable(final Type arg,
 		final TypeVariable<?> param,
 		final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds)
 	{
@@ -949,7 +949,7 @@ private static boolean satisfiesTypeVariable(final Type arg,
 		// if the type variable refers to some parameterized type (e.g. T extends
 		// List<?>), call satisfiesTypeParameters on the bounds of param that
 		// are ParameterizedTypes.
-		if(!satisfiesTypeVariableBounds(arg, param, typeBounds)) return false;
+		if(!isApplicableToTypeVariableBounds(arg, param, typeBounds)) return false;
 		return true;
 	}
 	
@@ -966,7 +966,7 @@ private static boolean satisfiesTypeVariable(final Type arg,
 	 * @return {@code boolean} - true if {@code arg} can satisfy the bounds of
 	 *         {@code param}.
 	 */
-	private static boolean satisfiesTypeVariableBounds(final Type arg,
+	private static boolean isApplicableToTypeVariableBounds(final Type arg,
 			final TypeVariable<?> param,
 			final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds)
 	{
@@ -985,17 +985,17 @@ private static boolean satisfiesTypeVariableBounds(final Type arg,
 						return false;
 					}
 					if (paramBoundTypes[i] instanceof TypeVariable<?> &&
-						!satisfiesTypeParameter(argType,
+						!isApplicableToTypeParameter(argType,
 							(TypeVariable<?>) paramBoundTypes[i], typeBounds)) return false;
-					else if (satisfies(new Type[] { argType }, new Type[] {
+					else if (isApplicable(new Type[] { argType }, new Type[] {
 						paramBoundTypes[i] }, typeBounds) != -1) return false;
 				}
 			}
 		}
 		return true;
 	}
 
-	private static boolean satisfiesWildcardType(final Type arg,
+	private static boolean isApplicableToWildcardType(final Type arg,
 		final WildcardType param)
 	{
 		final Type[] upperBounds = param.getUpperBounds();
@@ -1015,7 +1015,7 @@ private static boolean satisfiesWildcardType(final Type arg,
 		return true;
 	}
 
-	private static boolean satisfiesGenericArrayType(final Type arg,
+	private static boolean isApplicableToGenericArrayType(final Type arg,
 		final GenericArrayType param,
 		final HashMap<TypeVariable<?>, TypeVarInfo> typeBounds)
 	{
@@ -1028,15 +1028,15 @@ private static boolean satisfiesGenericArrayType(final Type arg,
 			final ParameterizedType argType = (ParameterizedType) argComponent;
 			final ParameterizedType paramType = (ParameterizedType) paramComponent;
 
-			if (!satisfiesParameterizedTypes(argType, paramType, typeBounds))
+			if (!isApplicableToParameterizedTypes(argType, paramType, typeBounds))
 				return false;
 		}
 
 		else if (paramComponent instanceof TypeVariable) {
 			// TODO are these casts safe?
 			final TypeVariable<?> paramType = (TypeVariable<?>) paramComponent;
 
-			if (!satisfiesTypeVariable(argComponent, paramType, typeBounds))
+			if (!isApplicableToTypeVariable(argComponent, paramType, typeBounds))
 				return false;
 		}
 
diff --git a/src/test/java/org/scijava/ops/util/TypesTest.java b/src/test/java/org/scijava/ops/util/TypesTest.java
