WIP: Substitute Any types in Op transformers

wiedenm · wiedenm · commit 9f4cbe2acd03 · 2019-06-28T14:11:21.000-05:00
Pretty hacky at the moment since we only implemented this substitution
for the first link in the transformation chain and also only for
computer-&gt;function conversion (and there, only rudimentary).

Also add AnyTest.testRunAnyBiFunctionFromBiComputer to cover further
work.

Note the fix in DefaultOpTypeMatchingService (logical not added).
diff --git a/src/main/java/net/imagej/ops/create/Creators.java b/src/main/java/net/imagej/ops/create/Creators.java
@@ -44,6 +44,8 @@
 import net.imglib2.util.Util;
 import net.imglib2.view.Views;
 
+import org.joml.Vector3d;
+import org.joml.Vector3f;
 import org.scijava.core.Priority;
 import org.scijava.ops.OpField;
 import org.scijava.ops.core.OpCollection;
@@ -524,4 +526,11 @@ public class Creators<N extends NativeType<N>, L, I extends IntegerType<I>, T ex
 	@Parameter(key = "nativeType", type = ItemIO.OUTPUT)
 	public final Function<Class<N>, N> nativeTypeFromClass = (clazz) -> (N) object.apply((Class<L>) clazz);
 
+	@OpField(names = "create.vector")
+	@Parameter(key = "vector3d", type = ItemIO.OUTPUT)
+	public final Source<Vector3d> defaultVector3d = () -> new Vector3d();
+
+	@OpField(names = "create.vector")
+	@Parameter(key = "vector3f", type = ItemIO.OUTPUT)
+	public final Source<Vector3f> defaultVector3f = () -> new Vector3f();
 }
diff --git a/src/main/java/org/scijava/ops/matcher/DefaultOpTypeMatchingService.java b/src/main/java/org/scijava/ops/matcher/DefaultOpTypeMatchingService.java
@@ -241,7 +241,7 @@ private boolean typesPerfectMatch(final OpCandidate candidate) {
 		}
 
 		final Type outputType = candidate.getRef().getOutType();
-		if (Objects.equals(outputType, OpUtils.outputType(candidate)))
+		if (!Objects.equals(outputType, OpUtils.outputType(candidate)))
 			return false;
 
 		candidate.setStatus(StatusCode.MATCH);
diff --git a/src/main/java/org/scijava/ops/transform/FunctionalToOpRunnerTransformer.java b/src/main/java/org/scijava/ops/transform/FunctionalToOpRunnerTransformer.java
@@ -170,6 +170,11 @@ private static OpTransformationException createInvalidSourceOpException(final Ob
 			problemArgs));
 	}
 
+	@Override
+	public OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef) {
+		throw new UnsupportedOperationException("not yet implemented");
+	}
+
 	@Override
 	public Collection<OpRef> getRefsTransformingTo(final OpRef targetRef) {
 		if (!isOpRunner(targetRef)) {
diff --git a/src/main/java/org/scijava/ops/transform/OpMapper.java b/src/main/java/org/scijava/ops/transform/OpMapper.java
@@ -84,6 +84,11 @@ default Object transform(final OpService opService, final Object src, final OpRe
 			" is not of required class: " + srcClass().getName());
 	}
 
+	@Override
+	default OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef) {
+		throw new UnsupportedOperationException("not yet implemented");
+	}
+	
 	/**
 	 * One-to-one specialization of {@link #getRefsTransformingTo(OpRef)}. Returns
 	 * a non-{@code null} source if one could be found and {@code null} otherwise.
diff --git a/src/main/java/org/scijava/ops/transform/OpTransformation.java b/src/main/java/org/scijava/ops/transform/OpTransformation.java
@@ -66,16 +66,21 @@ public OpTransformation getChild() {
 	 * be executed.
 	 * 
 	 * @param obj
+	 * @param targetRef2 
 	 * @param opService
 	 * @return
 	 * @throws OpTransformationException 
 	 */
-	public Object execute(Object obj, OpService opService) throws OpTransformationException {
+	public Object execute(Object obj, OpRef targetRef, OpService opService) throws OpTransformationException {
 		Object candidate = obj;
 		OpTransformation c = this;
+		OpRef tr = targetRef;
 		do {
-			candidate = c.getTransformer().transform(opService, candidate, c.targetRef);
+			candidate = c.getTransformer().transform(opService, candidate, tr);
 			c = c.getChild();
+			if (c != null) {
+				tr = c.getTarget();
+			}
 		} while (c != null);
 		
 		return candidate;
diff --git a/src/main/java/org/scijava/ops/transform/OpTransformationCandidate.java b/src/main/java/org/scijava/ops/transform/OpTransformationCandidate.java
@@ -1,10 +1,16 @@
+
 package org.scijava.ops.transform;
 
+import java.lang.reflect.Type;
 import java.util.List;
+import java.util.stream.Stream;
 
 import org.scijava.ops.OpService;
 import org.scijava.ops.matcher.OpCandidate;
+import org.scijava.ops.matcher.OpInfo;
 import org.scijava.ops.matcher.OpMatchingException;
+import org.scijava.ops.matcher.OpRef;
+import org.scijava.struct.Member;
 
 /**
  * Wrapper class to match a {@link OpTransformation} with a matching
@@ -21,11 +27,11 @@ public OpTransformationCandidate(OpCandidate scrOp, OpTransformation transformat
 		this.srcOp = scrOp;
 		this.transformation = transformation;
 	}
-	
+
 	public OpCandidate getSourceOp() {
 		return srcOp;
 	}
-	
+
 //	private void substituteAnyInTransformation() {
 //		// obtain the type info from the matched Op
 //		OpInfo srcInfo = srcOp.opInfo();
@@ -43,7 +49,13 @@ public Object exceute(OpService opService, List<?> dependencies, Object... secon
 	{
 		Object op = srcOp.createOp(dependencies, secondaryArgs);
 //		substituteAnyInTransformation();
-		return transformation.execute(op, opService);
+
+		OpInfo srcInfo = srcOp.opInfo();
+		OpRef srcRef = new OpRef(srcOp.getRef().getName(), new Type[] { srcInfo.opType() }, srcInfo.output().getType(),
+			srcInfo.inputs().stream().map(Member::getType).toArray(Type[]::new));
+		OpRef targetRef = transformation.getTransformer().substituteAnyInTargetRef(srcRef, transformation.getTarget());
+
+		return transformation.execute(op, targetRef, opService);
 	}
 
 	@Override
diff --git a/src/main/java/org/scijava/ops/transform/OpTransformer.java b/src/main/java/org/scijava/ops/transform/OpTransformer.java
@@ -62,6 +62,9 @@ public interface OpTransformer extends SingletonPlugin {
 	 */
 	Object transform(OpService opService, Object src, OpRef targetRef) throws OpTransformationException;
 
+	
+	OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef);
+	
 	/**
 	 * Returns a collection that contains the {@link OpRef}s of all Ops which can
 	 * be transformed into the Op described by the given {@code targetRef} using
diff --git a/src/main/java/org/scijava/ops/transform/functional/ComputerToFunctionTransformer.java b/src/main/java/org/scijava/ops/transform/functional/ComputerToFunctionTransformer.java
@@ -193,6 +193,13 @@ private static <I1, I2, I3, I4, I5, O> Function5<I1, I2, I3, I4, I5, O> computer
 			: Adapt.Computers.asFunction5(src, (Source<O>) create);
 	}
 
+	@Override
+	public OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef) {
+		final Type[] targetTypes = srcRef.getTypes();
+		TypeModUtils.replaceRawTypes(targetTypes, Types.raw(srcRef.getTypes()[0]), Types.raw(targetRef.getTypes()[0]));
+		return new OpRef(targetRef.getName(), targetTypes, srcRef.getOutType(), targetRef.getArgs());
+	}
+	
 	@Override
 	public Integer getTargetArity(final Class<?> targetFunctionalRawType) {
 		return Functions.ALL_FUNCTIONS.get(targetFunctionalRawType);
diff --git a/src/main/java/org/scijava/ops/transform/functional/FunctionToComputerTransformer.java b/src/main/java/org/scijava/ops/transform/functional/FunctionToComputerTransformer.java
@@ -128,6 +128,11 @@ private static <I1, I2, O> BiComputer<I1, I2, O> functionToComputer(final BiFunc
 		return Adapt.Functions.asBiComputer(src, (Computer<O, O>) copy);
 	}
 
+	@Override
+	public OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef) {
+		throw new UnsupportedOperationException("not yet implemented");
+	}
+	
 	@Override
 	public Integer getTargetArity(final Class<?> targetFunctionalRawType) {
 		return Computers.ALL_COMPUTERS.get(targetFunctionalRawType);
diff --git a/src/main/java/org/scijava/ops/transform/functional/InplaceToFunctionTransformer.java b/src/main/java/org/scijava/ops/transform/functional/InplaceToFunctionTransformer.java
@@ -114,6 +114,11 @@ else if (targetFunctionalRawType == null) {
 		}
 	}
 
+	@Override
+	public OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef) {
+		throw new UnsupportedOperationException("not yet implemented");
+	}
+
 	@Override
 	public Integer getTargetArity(final Class<?> targetFunctionalRawType) {
 		return Functions.ALL_FUNCTIONS.get(targetFunctionalRawType);
diff --git a/src/test/java/org/scijava/ops/types/AnyTest.java b/src/test/java/org/scijava/ops/types/AnyTest.java
@@ -1,12 +1,19 @@
 package org.scijava.ops.types;
 
+import static org.junit.Assert.assertEquals;
+
 import java.lang.reflect.Type;
 import java.util.function.Function;
 
 import org.junit.Test;
 import org.scijava.core.Priority;
 import org.scijava.ops.AbstractTestEnvironment;
 import org.scijava.ops.core.Op;
+import org.scijava.ops.core.Source;
+import org.scijava.ops.core.computer.BiComputer;
+import org.scijava.ops.core.computer.Computer;
+import org.scijava.ops.util.Functions;
+import org.scijava.param.Mutable;
 import org.scijava.param.Parameter;
 import org.scijava.plugin.Plugin;
 import org.scijava.struct.ItemIO;
@@ -59,6 +66,52 @@ public Class<Thing<?>> getRawType() {
 
 	}
 
+	// TODO: Note that this wouldn't work for Computer -> Function because here
+	// LiftFunctionToArrayTransformer is the first transformer which is asked for
+	// source refs. This transformer doesn't support Any and would fail.
+	@Test
+	public void testRunAnyBiFunctionFromBiComputer() {
+		final int in1 = 11;
+		final long in2 = 31;
+		final Object out = ops.run("test.integerAndLongAndNotAnyComputer", in1, in2);
+		assert out instanceof MutableNotAny;
+		assertEquals(Long.toString(in1 + in2), ((MutableNotAny) out).getValue());
+	}
+}
+
+@Plugin(type = Op.class, name = "test.integerAndLongAndNotAnyComputer")
+@Parameter(key = "input1")
+@Parameter(key = "input2")
+@Parameter(key = "output", type = ItemIO.BOTH)
+class IntegerAndLongAndNotAnyComputer implements BiComputer<Integer, Long, MutableNotAny> {
+
+	@Override
+	public void compute(Integer in1, Long in2, @Mutable MutableNotAny out) {
+		out.setValue(Long.toString(in1 + in2));
+	}
+}
+
+class MutableNotAny {
+
+	private String value;
+
+	public String getValue() {
+		return value;
+	}
+
+	public void setValue(String value) {
+		this.value = value;
+	}
+}
+
+@Plugin(type = Op.class, name = "create.mutableNotAny")
+@Parameter(key = "mutableNotAny", type = ItemIO.OUTPUT)
+class MutableNotAnyCreator implements Source<MutableNotAny> {
+
+	@Override
+	public MutableNotAny create() {
+		return new MutableNotAny();
+	}
 }
 
 class Thing<U> {

Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ private boolean typesPerfectMatch(final OpCandidate candidate) {`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`final Type outputType = candidate.getRef().getOutType();`
`244`		`- if (Objects.equals(outputType, OpUtils.outputType(candidate)))`
	`244`	`+ if (!Objects.equals(outputType, OpUtils.outputType(candidate)))`
`245`	`245`	`return false;`
`246`	`246`
`247`	`247`	`candidate.setStatus(StatusCode.MATCH);`
Original file line number	Diff line number	Diff line change
`@@ -114,6 +114,11 @@ else if (targetFunctionalRawType == null) {`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
	`117`	`+ @Override`
	`118`	`+ public OpRef substituteAnyInTargetRef(OpRef srcRef, OpRef targetRef) {`
	`119`	`+ throw new UnsupportedOperationException("not yet implemented");`
	`120`	`+ }`
	`121`	`+`
`117`	`122`	`@Override`
`118`	`123`	`public Integer getTargetArity(final Class<?> targetFunctionalRawType) {`
`119`	`124`	`return Functions.ALL_FUNCTIONS.get(targetFunctionalRawType);`