Clean OpEnvironment

gselzer · ctrueden · commit c8d195a8093d · 2021-11-19T22:29:07.000-06:00
diff --git a/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/OpEnvironment.java b/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/OpEnvironment.java
@@ -128,31 +128,6 @@ InfoChain infoChain(final String opName, final Nil<?> specialType,
 	InfoChain infoChain(final String opName, final Nil<?> specialType,
 		final Nil<?>[] inTypes, final Nil<?> outType, Hints hints);
 
-	/**
-	 * Returns an Op fitting the provided arguments. NB implementations of this
-	 * method likely depend on the {@link Hints} set by
-	 * {@link OpEnvironment#setDefaultHints(Hints)}, which provides no guarantee of
-	 * thread-safety. Users interested in parallel Op matching should consider
-	 * using {@link OpEnvironment#opFromInfo(String, Nil, Hints)} instead.
-	 *
-	 * @param <T> the {@link Type} of the Op
-	 * @param info the {@link OpInfo}
-	 * @param specialType the generic {@link Type} of the Op
-	 * @return an instance of an Op aligning with the search parameters
-	 */
-	<T> T opFromInfo(OpInfo info, Nil<T> specialType);
-
-	/**
-	 * Returns an Op fitting the provided arguments.
-	 *
-	 * @param <T> the {@link Type} of the Op
-	 * @param info the {@link OpInfo}
-	 * @param specialType the generic {@link Type} of the Op
-	 * @param hints the {@link Hints} that should guide this matching call
-	 * @return an instance of an Op aligning with the search parameters
-	 */
-	<T> T opFromInfo(OpInfo info, Nil<T> specialType, Hints hints);
-
 	<T> T opFromInfoChain(InfoChain chain, Nil<T> specialType);
 
 	/**
diff --git a/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/impl/DefaultOpEnvironment.java b/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/impl/DefaultOpEnvironment.java
@@ -238,24 +238,6 @@ public InfoChain infoChain(String opName, Nil<?> specialType,
 			throw new IllegalArgumentException(e);
 		}
 	}
-	
-	@Override
-	public <T> T opFromInfo(final OpInfo info, final Nil<T> specialType, Hints hints) {
-		try {
-			return findOp(info, specialType, hints).asOpType();
-		} catch (OpMatchingException e) {
-			throw new IllegalArgumentException(e);
-		}
-	}
-
-	@Override
-	public <T> T opFromInfo(final OpInfo info, final Nil<T> specialType) {
-		try {
-			return findOp(info, specialType, getDefaultHints()).asOpType();
-		} catch (OpMatchingException e) {
-			throw new IllegalArgumentException(e);
-		}
-	}
 
 	@Override
 	public InfoChain chainFromInfo(OpInfo info, Nil<?> specialType) {
@@ -496,8 +478,8 @@ private OpInstance<?> instantiateOp(final OpCandidate candidate, Hints hints)
 	/**
 	 * Wraps the matched op into an {@link Op} that knows its generic typing.
 	 * 
-	 * @param op - the op to wrap.
-	 * @param opInfo - from which we determine the {@link Type} of the {@code Op}
+	 * @param instance - the {@link OpInstance} to wrap.
+	 * @param hints - the {@link Hints} used to create the {@link OpInstance}
 	 *            
 	 * @return an {@link Op} wrapping of op.
 	 */
@@ -559,6 +541,7 @@ private List<RichOp<?>> resolveOpDependencies(OpCandidate candidate, Hints hints
 		return resolveOpDependencies(candidate.opInfo(), candidate.typeVarAssigns(), hints);
 	}
 
+	@SuppressWarnings("rawtypes")
 	private synchronized void initWrappers() {
 		if (wrappers != null) return;
 		wrappers = new HashMap<>();
@@ -769,7 +752,7 @@ private OpRef inferOpRef(OpDependencyMember<?> dependency,
 	 * 
 	 * Input and output types will be inferred by looking at the signature of the
 	 * functional method of the specified type. Also see
-	 * {@link ParameterStructs#findFunctionalMethodTypes(Type)}.
+	 * {@link FunctionalParameters#findFunctionalMethodTypes(Type)}.
 	 *
 	 * @param type
 	 * @param name
diff --git a/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/simplify/SimplificationUtils.java b/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/simplify/SimplificationUtils.java
@@ -8,7 +8,6 @@
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -21,13 +20,11 @@
 import org.scijava.function.Computers;
 import org.scijava.function.Container;
 import org.scijava.function.Mutable;
-import org.scijava.ops.api.InfoChain;
 import org.scijava.ops.api.OpEnvironment;
 import org.scijava.ops.api.OpInfo;
 import org.scijava.ops.api.OpRef;
 import org.scijava.ops.api.OpUtils;
 import org.scijava.ops.engine.util.internal.AnnotationUtils;
-import org.scijava.types.Nil;
 import org.scijava.types.Types;
 import org.scijava.types.inference.GenericAssignability;
 import org.scijava.types.inference.InterfaceInference;
@@ -162,30 +159,6 @@ public static Type resolveMutatorTypeArgs(Type inferFrom, Type mutatorInferFrom,
 		return Types.mapVarToTypes(unresolvedType, map);
 	}
 
-	/**
-	 * Finds required mutators (i.e. simplifier or focuser).
-	 * 
-	 * @param mutatorInfos - the {@link OpInfo}s for which Ops are needed
-	 * @return a set of {@code Op}s, instantiated from {@code mutatorInfo}s, that
-	 *         satisfy the prescribed input/output types.
-	 */
-	public static List<Function<?, ?>> findArgMutators(List<InfoChain> mutatorInfos)
-	{
-		List<Function<?, ?>> mutators = new ArrayList<>();
-		for(int i = 0; i < mutatorInfos.size(); i++) {
-			Function<?, ?> mutator = (Function<?, ?>) mutatorInfos.get(i).op().op();
-			mutators.add(mutator);
-		}
-		return mutators;
-	}
-	
-	public static Function<?, ?> findArgMutator(OpEnvironment env, OpInfo mutatorInfo, Type originalInput, Type mutatedInput){
-			Type opType = Types.parameterize(Function.class, new Type[] {originalInput, mutatedInput});
-			Function<?, ?> mutator = (Function<?, ?>) env.opFromInfo(mutatorInfo,
-				Nil.of(opType));
-			return mutator;
-	}
-
 	/**
 	 * Uses Google Guava to generate a list of permutations of each available
 	 * simplification possibility
