Rename InstanceChain.op()

gselzer · ctrueden · commit c361aa867ed7 · 2022-07-01T16:25:58.000-05:00
We were conflating too many things with the name op()
diff --git a/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/InfoChain.java b/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/InfoChain.java
@@ -79,17 +79,17 @@ public OpInfo info() {
 		return info;
 	}
 
-	public OpInstance<?> op() {
+	public OpInstance<?> newInstance() {
 		return OpInstance.of(generateOp(), this, info.opType());
 	}
 
-	public OpInstance<?> op(Type opType) {
+	public OpInstance<?> newInstance(Type opType) {
 		return OpInstance.of(generateOp(), this, opType);
 	}
 
 	protected Object generateOp() {
 		List<Object> dependencyInstances = dependencies().stream() //
-			.map(d -> d.op().op()) //
+			.map(d -> d.newInstance().op()) //
 			.collect(Collectors.toList());
 		Object op = info().createOpInstance(dependencyInstances).object();
 		return op;
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
@@ -245,7 +245,7 @@ public <T> T opFromInfoChain(final InfoChain chain,
 		if (!(specialType.getType() instanceof ParameterizedType))
 			throw new IllegalArgumentException("TODO");
 		@SuppressWarnings("unchecked")
-		OpInstance<T> instance = (OpInstance<T>) chain.op(specialType.getType());
+		OpInstance<T> instance = (OpInstance<T>) chain.newInstance(specialType.getType());
 		Hints hints = getDefaultHints();
 		RichOp<T> wrappedOp = wrapOp(instance, hints);
 		return wrappedOp.asOpType();
@@ -423,7 +423,7 @@ private OpInstance<?> instantiateOp(final OpCandidate candidate,
 		final List<RichOp<?>> conditions = resolveOpDependencies(candidate, hints);
 		InfoChain adaptorChain = new DependencyRichOpInfoChain(candidate
 			.opInfo(), conditions);
-		return adaptorChain.op(candidate.getType());
+		return adaptorChain.newInstance(candidate.getType());
 	}
 
 	/**
diff --git a/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/impl/OpAdaptationInfo.java b/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/impl/OpAdaptationInfo.java
@@ -115,7 +115,7 @@ public String implementationName() {
 	public StructInstance<?> createOpInstance(List<?> dependencies) {
 		@SuppressWarnings("unchecked")
 		OpInstance<Function<Object, Object>> adaptorInstance =
-			(OpInstance<Function<Object, Object>>) adaptorChain.op(
+			(OpInstance<Function<Object, Object>>) adaptorChain.newInstance(
 				new Nil<Function<Object, Object>>()
 				{}.getType());
 		final Object op = srcInfo.createOpInstance(dependencies).object();
diff --git a/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/simplify/SimplificationMetadata.java b/scijava/scijava-ops-engine/src/main/java/org/scijava/ops/engine/simplify/SimplificationMetadata.java
@@ -76,16 +76,16 @@ public SimplificationMetadata(OpInfo info, List<InfoChain> refSimplifiers, List<
 		this.opType = Types.raw(info.opType());
 		
 		this.refSimplifiers = refSimplifiers;
-		this.inputSimplifiers = refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());
+		this.inputSimplifiers = refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());
 
 		this.infoFocusers = infoFocusers;
-		this.inputFocusers = infoFocusers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());
+		this.inputFocusers = infoFocusers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());
 
 		this.infoSimplifier = infoSimplifier;
-		this.outputSimplifier = (Function<?, ?>) infoSimplifier.op().op();
+		this.outputSimplifier = (Function<?, ?>) infoSimplifier.newInstance().op();
 
 		this.refFocuser = refFocuser;
-		this.outputFocuser = (Function<?, ?>) refFocuser.op().op();
+		this.outputFocuser = (Function<?, ?>) refFocuser.newInstance().op();
 
 		this.copyOpChain = outputCopier;
 
@@ -111,22 +111,22 @@ public SimplificationMetadata(OpInfo info, List<InfoChain> refSimplifiers, List<
 
 	private static List<Function<?, ?>> inputSimplifiers(List<InfoChain> refSimplifiers)
 	{
-		return refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());
+		return refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());
 	}
 
 	private static List<Function<?, ?>> inputFocusers(List<InfoChain> infoFocusers)
 	{
-		return infoFocusers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());
+		return infoFocusers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());
 	}
 
 	private static Function<?, ?> outputSimplifier(InfoChain infoSimplifier)
 	{
-		return (Function<?, ?>) infoSimplifier.op().op();
+		return (Function<?, ?>) infoSimplifier.newInstance().op();
 	}
 
 	private static Function<?, ?> outputFocuser(InfoChain refFocuser)
 	{
-		return (Function<?, ?>) refFocuser.op().op();
+		return (Function<?, ?>) refFocuser.newInstance().op();
 	}
 
 	public List<Function<?, ?>> inputSimpilfiers() {
@@ -195,7 +195,7 @@ public InfoChain copyOpChain() {
 
 	public Computers.Arity1<?, ?> copyOp() {
 		// TODO: Should we prevent multiple instantiations?
-		return (Arity1<?, ?>) copyOpChain.get().op().op();
+		return (Arity1<?, ?>) copyOpChain.get().newInstance().op();
 	}
 
 	/**

Original file line number	Diff line number	Diff line change
`@@ -79,17 +79,17 @@ public OpInfo info() {`
`79`	`79`	`return info;`
`80`	`80`	`}`
`81`	`81`
`82`		`- public OpInstance<?> op() {`
	`82`	`+ public OpInstance<?> newInstance() {`
`83`	`83`	`return OpInstance.of(generateOp(), this, info.opType());`
`84`	`84`	`}`
`85`	`85`
`86`		`- public OpInstance<?> op(Type opType) {`
	`86`	`+ public OpInstance<?> newInstance(Type opType) {`
`87`	`87`	`return OpInstance.of(generateOp(), this, opType);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`protected Object generateOp() {`
`91`	`91`	`List<Object> dependencyInstances = dependencies().stream() //`
`92`		`- .map(d -> d.op().op()) //`
	`92`	`+ .map(d -> d.newInstance().op()) //`
`93`	`93`	`.collect(Collectors.toList());`
`94`	`94`	`Object op = info().createOpInstance(dependencyInstances).object();`
`95`	`95`	`return op;`
Original file line number	Diff line number	Diff line change
`@@ -76,16 +76,16 @@ public SimplificationMetadata(OpInfo info, List<InfoChain> refSimplifiers, List<`
`76`	`76`	`this.opType = Types.raw(info.opType());`
`77`	`77`
`78`	`78`	`this.refSimplifiers = refSimplifiers;`
`79`		`- this.inputSimplifiers = refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());`
	`79`	`+ this.inputSimplifiers = refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());`
`80`	`80`
`81`	`81`	`this.infoFocusers = infoFocusers;`
`82`		`- this.inputFocusers = infoFocusers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());`
	`82`	`+ this.inputFocusers = infoFocusers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());`
`83`	`83`
`84`	`84`	`this.infoSimplifier = infoSimplifier;`
`85`		`- this.outputSimplifier = (Function<?, ?>) infoSimplifier.op().op();`
	`85`	`+ this.outputSimplifier = (Function<?, ?>) infoSimplifier.newInstance().op();`
`86`	`86`
`87`	`87`	`this.refFocuser = refFocuser;`
`88`		`- this.outputFocuser = (Function<?, ?>) refFocuser.op().op();`
	`88`	`+ this.outputFocuser = (Function<?, ?>) refFocuser.newInstance().op();`
`89`	`89`
`90`	`90`	`this.copyOpChain = outputCopier;`
`91`	`91`
`@@ -111,22 +111,22 @@ public SimplificationMetadata(OpInfo info, List<InfoChain> refSimplifiers, List<`
`111`	`111`
`112`	`112`	`private static List<Function<?, ?>> inputSimplifiers(List<InfoChain> refSimplifiers)`
`113`	`113`	`{`
`114`		`- return refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());`
	`114`	`+ return refSimplifiers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`private static List<Function<?, ?>> inputFocusers(List<InfoChain> infoFocusers)`
`118`	`118`	`{`
`119`		`- return infoFocusers.stream().map(chain -> (Function<?, ?>) chain.op().op()).collect(Collectors.toList());`
	`119`	`+ return infoFocusers.stream().map(chain -> (Function<?, ?>) chain.newInstance().op()).collect(Collectors.toList());`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`private static Function<?, ?> outputSimplifier(InfoChain infoSimplifier)`
`123`	`123`	`{`
`124`		`- return (Function<?, ?>) infoSimplifier.op().op();`
	`124`	`+ return (Function<?, ?>) infoSimplifier.newInstance().op();`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`private static Function<?, ?> outputFocuser(InfoChain refFocuser)`
`128`	`128`	`{`
`129`		`- return (Function<?, ?>) refFocuser.op().op();`
	`129`	`+ return (Function<?, ?>) refFocuser.newInstance().op();`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`public List<Function<?, ?>> inputSimpilfiers() {`
`@@ -195,7 +195,7 @@ public InfoChain copyOpChain() {`
`195`	`195`
`196`	`196`	`public Computers.Arity1<?, ?> copyOp() {`
`197`	`197`	`// TODO: Should we prevent multiple instantiations?`
`198`		`- return (Arity1<?, ?>) copyOpChain.get().op().op();`
	`198`	`+ return (Arity1<?, ?>) copyOpChain.get().newInstance().op();`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`/**`