Add new OpRunner Transformations

gselzer · ctrueden · commit 34e5dea84130 · 2019-06-11T12:43:31.000-05:00
diff --git a/src/main/java/org/scijava/ops/core/inplace/Inplace7Second.java b/src/main/java/org/scijava/ops/core/inplace/Inplace7Second.java
@@ -0,0 +1,14 @@
+package org.scijava.ops.core.inplace;
+
+import org.scijava.ops.core.Consumer7;
+import org.scijava.param.Mutable;
+
+@FunctionalInterface
+public interface Inplace7Second<I1, IO, I3, I4, I5, I6, I7> extends Consumer7<I1, IO, I3, I4, I5, I6, I7> {
+	void mutate(I1 in1, @Mutable IO io, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7);
+
+	@Override
+	default void accept(I1 in1, IO io, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7) {
+		mutate(in1, io, in3, in4, in5, in6, in7);
+	}
+}
diff --git a/src/main/java/org/scijava/ops/transform/functional/Inplace3FirstToOpRunnerTransformer.java b/src/main/java/org/scijava/ops/transform/functional/Inplace3FirstToOpRunnerTransformer.java
@@ -55,15 +55,11 @@ public OpRef getRefTransformingTo(OpRef toRef) {
 		// OpRunner) into one array so that we can use them to parameterize the
 		// BiFunction.
 		Type[] toParamTypes = getTransformedArgTypes(toRef);
-//		Type[] toParamTypes = Stream
-//				.concat(Arrays.stream(getTransformedArgTypes(toRef)), Arrays.stream(getTransformedOutputTypes(toRef)))
-//				.toArray(Type[]::new);
 
 		// parameterize the OpRef types with the 3 BiFunction type parameters
 		Type[] refTypes = Arrays.stream(toRef.getTypes())
 				.map(refType -> Types.parameterize(Types.raw(refType), toParamTypes)).toArray(Type[]::new);
 
-		// from here it is the s
 		boolean hit = TypeModUtils.replaceRawTypes(refTypes, targetClass(), srcClass());
 		if (hit) {
 			return OpRef.fromTypes(toRef.getName(), refTypes, getTransformedOutputTypes(toRef),
diff --git a/src/main/java/org/scijava/ops/transform/functional/Inplace3SecondToOpRunnerTransformer.java b/src/main/java/org/scijava/ops/transform/functional/Inplace3SecondToOpRunnerTransformer.java
@@ -0,0 +1,70 @@
+package org.scijava.ops.transform.functional;
+
+import java.lang.reflect.Type;
+import java.util.Arrays;
+
+import org.scijava.ops.OpService;
+import org.scijava.ops.core.inplace.Inplace3Second;
+import org.scijava.ops.matcher.OpRef;
+import org.scijava.ops.transform.OpRunner;
+import org.scijava.ops.transform.OpTransformer;
+import org.scijava.ops.transform.TypeModUtils;
+import org.scijava.ops.types.TypeService;
+import org.scijava.ops.util.OpRunners;
+import org.scijava.plugin.Parameter;
+import org.scijava.plugin.Plugin;
+import org.scijava.util.Types;
+
+@Plugin(type = OpTransformer.class)
+public class Inplace3SecondToOpRunnerTransformer implements FunctionalTypeTransformer {
+
+	@Parameter
+	private TypeService typeService;
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Object transform(OpService opService, OpRef ref, Object src) {
+//		Type[] outTypes = ref.getOutTypes();
+		return OpRunners.Inplaces.toRunner((Inplace3Second) src);
+	}
+
+	@Override
+	public Class<?> srcClass() {
+		return Inplace3Second.class;
+	}
+
+	@Override
+	public Class<?> targetClass() {
+		return OpRunner.class;
+	}
+
+	@Override
+	public Type[] getTransformedArgTypes(OpRef toRef) {
+		return toRef.getArgs();
+	}
+
+	@Override
+	public Type[] getTransformedOutputTypes(OpRef toRef) {
+		return toRef.getOutTypes();
+	}
+
+	@Override
+	public OpRef getRefTransformingTo(OpRef toRef) {
+
+		// concatenate the input and output types of the BiFunction (as described by the
+		// OpRunner) into one array so that we can use them to parameterize the
+		// BiFunction.
+		Type[] toParamTypes = getTransformedArgTypes(toRef);
+
+		// parameterize the OpRef types with the 3 BiFunction type parameters
+		Type[] refTypes = Arrays.stream(toRef.getTypes())
+				.map(refType -> Types.parameterize(Types.raw(refType), toParamTypes)).toArray(Type[]::new);
+
+		boolean hit = TypeModUtils.replaceRawTypes(refTypes, targetClass(), srcClass());
+		if (hit) {
+			return OpRef.fromTypes(toRef.getName(), refTypes, getTransformedOutputTypes(toRef),
+					getTransformedArgTypes(toRef));
+		}
+		return null;
+	}
+}
diff --git a/src/main/java/org/scijava/ops/util/Adapt.java b/src/main/java/org/scijava/ops/util/Adapt.java
@@ -19,6 +19,7 @@
 import org.scijava.ops.core.inplace.BiInplaceSecond;
 import org.scijava.ops.core.inplace.Inplace;
 import org.scijava.ops.core.inplace.Inplace3First;
+import org.scijava.ops.core.inplace.Inplace3Second;
 import org.scijava.ops.core.inplace.Inplace4First;
 import org.scijava.ops.core.inplace.Inplace5First;
 
@@ -232,6 +233,19 @@ public static <I1, I2, I3, O> BiComputer<I1, I2, O> asBiComputer(final Computer3
 	}
 	
 	public static class Inplaces {
+		
+		public static <IO, I2> Inplace<IO> asInplace(BiInplaceFirst<IO, I2> inplace, I2 in2) {
+			return (io) -> {
+				inplace.mutate(io, in2);
+			};
+		}
+		
+		public static <I1, IO> Inplace<IO> asInplace(BiInplaceSecond<I1, IO> inplace, I1 in1) {
+			return (io) -> {
+				inplace.mutate(in1, io);
+			};
+		}
+		
 		public static <IO> Function<IO, IO> asFunction(Inplace<IO> inplace){
 			return (io) -> {
 				inplace.mutate(io);
@@ -260,6 +274,13 @@ public static <IO, I2, I3> Function3<IO, I2, I3, IO> asFunction3(Inplace3First<I
 			};
 		}
 		
+		public static <I1, IO, I3> Function3<I1, IO, I3, IO> asFunction3(Inplace3Second<I1, IO, I3> inplace){
+			return (in1, io, in3) -> {
+				inplace.mutate(in1, io, in3);
+				return io;
+			};
+		}
+		
 		public static <IO, I2, I3, I4> Function4<IO, I2, I3, I4, IO> asFunction4(Inplace4First<IO, I2, I3, I4> inplace){
 			return (io, in2, in3, in4) -> {
 				inplace.mutate(io, in2, in3, in4);
diff --git a/src/main/java/org/scijava/ops/util/OpRunners.java b/src/main/java/org/scijava/ops/util/OpRunners.java
@@ -16,6 +16,7 @@
 import org.scijava.ops.core.inplace.BiInplaceSecond;
 import org.scijava.ops.core.inplace.Inplace;
 import org.scijava.ops.core.inplace.Inplace3First;
+import org.scijava.ops.core.inplace.Inplace3Second;
 import org.scijava.ops.core.inplace.Inplace4First;
 import org.scijava.ops.core.inplace.Inplace5First;
 import org.scijava.ops.transform.OpRunner;
@@ -381,6 +382,30 @@ public IO run(Object[] args) {
 
 			};
 		}
+		
+		public static <I1, IO, I3> OpRunner<IO> toRunner(Inplace3Second<I1, IO, I3> inplace) {
+			return new OpRunner<IO>() {
+				
+				@Override
+				public Object getAdaptedOp() {
+					return inplace;
+				}
+				
+				@Override
+				public Nil<?>[] inTypes() {
+					return new Nil<?>[] { new Nil<I1>() {
+					}, new Nil<IO>() {
+					}, new Nil<I3>() {
+					} };
+				}
+
+				@Override
+				public IO run(Object[] args) {
+					return Adapt.Inplaces.asFunction3(inplace).apply((I1) args[0], (IO) args[1], (I3) args[2]);
+				}
+
+			};
+		}
 
 		public static <IO, I2, I3, I4> OpRunner<IO> toRunner(Inplace4First<IO, I2, I3, I4> inplace) {
 			return new OpRunner<IO>() {
