Split DefaultNodeModule & DefaultNodeModuleService into Command- & Script-

Signed-off-by: Squareys <[email protected]>

Author: Squareys

org.knime.scijava.commands/src/org/knime/scijava/commands/module/DefaultNodeModule.java renamed to org.knime.scijava.commands/src/org/knime/scijava/commands/module/AbstractNodeModule.java

@@ -8,6 +8,7 @@
 import org.knime.core.data.DataCell;
 import org.knime.core.data.DataRow;
 import org.knime.core.data.DataType;
+import org.knime.core.data.filestore.FileStore;
 import org.knime.core.node.ExecutionContext;
 import org.knime.core.node.NodeLogger;
 import org.knime.scijava.commands.CellOutput;
@@ -30,24 +31,23 @@
  *
  * @author Christian Dietz, University of Konstanz
  */
-class DefaultNodeModule implements NodeModule {
+abstract class AbstractNodeModule implements NodeModule {
 
     @Parameter
     private PluginService ps;
 
     @Parameter
-    private KNIMEConverterService cs;
+    private KNIMEConverterService convertService;
 
     @Parameter
     private ModuleService ms;
 
-    // Internally used variables
-    private final Module module;
-
     private final Map<Integer, ModuleItem<?>> inputMapping;
-
     private final Map<ModuleItem<?>, DataType> outputMapping;
 
+    private final ModuleInfo moduleInfo;
+    private final Module module;
+
     private NodeModuleOutputChangedListener outputListener;
 
     private final LogService logService;
@@ -68,7 +68,7 @@ class DefaultNodeModule implements NodeModule {
      * @param logger
      *            NodeLogger to delegate output to.
      */
-    public DefaultNodeModule(final Context context, final ModuleInfo info,
+    public AbstractNodeModule(final Context context, final ModuleInfo info,
             final Map<String, Object> params,
             final Map<Integer, ModuleItem<?>> inputMapping,
             final Map<ModuleItem<?>, DataType> outputMapping,
@@ -77,8 +77,9 @@ public DefaultNodeModule(final Context context, final ModuleInfo info,
 
         this.inputMapping = inputMapping;
         this.outputMapping = outputMapping;
+        this.moduleInfo = info;
         this.module = ms.createModule(info);
-        this.outputListener = new NodeModuleOutputChangedListener(false);
+        this.outputListener = new NodeModuleOutputChangedListener(true);
         this.logService = new KNIMELogService(logger);
 
         preProcess(params);
@@ -96,7 +97,6 @@ private void preProcess(final Map<String, Object> params) {
             module.resolveInput(entry.getKey());
         }
 
-        // FIXME: do we need them all?
         final List<PreprocessorPlugin> pre = ps
                 .createInstancesOfType(PreprocessorPlugin.class);
 
@@ -109,7 +109,7 @@ private void preProcess(final Map<String, Object> params) {
                 /* MultiOutputListener */
                 final String name = item.getName();
 
-                outputListener = new NodeModuleOutputChangedListener(true);
+                outputListener = new NodeModuleOutputChangedListener(false);
                 module.setInput(name, outputListener);
                 module.resolveInput(name);
             } else if (LogService.class.equals(item.getType())) {
@@ -125,12 +125,12 @@ private void preProcess(final Map<String, Object> params) {
     /*
      * Set module input values from the input row.
      */
-    private void setModuleInput(final DataRow input) throws Exception {
+    protected void setModuleInput(final DataRow input) throws Exception {
         // input can be null if source node
         if (input != null) {
             for (final Entry<Integer, ModuleItem<?>> entry : inputMapping
                     .entrySet()) {
-                final Object obj = cs.convertToJava(
+                final Object obj = convertService.convertToJava(
                         input.getCell(entry.getKey()),
                         entry.getValue().getType());
                 module.setInput(entry.getValue().getName(), obj);
@@ -151,42 +151,76 @@ public void run(final DataRow input, final CellOutput output,
         outputListener.flush();
     }
 
+    /**
+     * Create cells for the currently set output {@link ModuleItem}s of the
+     * module.
+     *
+     * @param context
+     *            Execution Context to use when creating {@link FileStore}s
+     * @return array of cells with the values of the module output
+     * @throws Exception
+     */
+    protected DataCell[] getModuleOutput(final ExecutionContext context)
+            throws Exception {
+        final List<DataCell> cells = new ArrayList<DataCell>();
+        for (final ModuleItem<?> entry : getInfo().outputs()) {
+            cells.add(convertService.convertToKnime(
+                    getModule().getOutput(entry.getName()), entry.getType(),
+                    getOutputMapping().get(entry), context));
+        }
+
+        return cells.toArray(new DataCell[cells.size()]);
+    }
+
+    @Override
+    public Map<Integer, ModuleItem<?>> getIntputMapping() {
+        return inputMapping;
+    }
+
+    @Override
+    public Map<ModuleItem<?>, DataType> getOutputMapping() {
+        return outputMapping;
+    }
+
+    @Override
+    public ModuleInfo getInfo() {
+        return moduleInfo;
+    }
+
+    @Override
+    public Module getModule() {
+        return module;
+    }
+
+    protected final KNIMEConverterService getConvertService() {
+        return convertService;
+    }
+
     private class NodeModuleOutputChangedListener
             implements MultiOutputListener {
         private ExecutionContext ctx;
 
         private CellOutput output;
 
         /* true if the modules handles pushes itself, false otherwise */
-        private final boolean manualPush;
+        private final boolean pushOnFlush;
 
         /**
          * Constructor.
          *
-         * @param manualPush
-         *            if <code>true</code>, signals that the module handles
-         *            pushing rows.
+         * @param pushOnFlush
+         *            if <code>true</code>, will push a final row when flush is
+         *            called.
          */
-        public NodeModuleOutputChangedListener(final boolean manualPush) {
-            this.manualPush = manualPush;
+        public NodeModuleOutputChangedListener(final boolean pushOnFlush) {
+            this.pushOnFlush = pushOnFlush;
         }
 
         @Override
         public void notifyListener() throws Exception {
             // output can be null if sink node
             if (output != null) {
-                final List<DataCell> cells = new ArrayList<DataCell>();
-                for (final ModuleItem<?> entry : module.getInfo().outputs()) {
-                    // FIXME hack because e.g. python script contains
-                    // result log
-                    if (!entry.getName().equals("result")) {
-                        cells.add(cs.convertToKnime(
-                                module.getOutput(entry.getName()),
-                                entry.getType(), outputMapping.get(entry),
-                                ctx));
-                    }
-                }
-                output.push(cells.toArray(new DataCell[cells.size()]));
+                output.push(getModuleOutput(ctx));
             }
         }
 
@@ -213,10 +247,11 @@ public void setCellOutput(final CellOutput output) {
         /**
          * Final flush. Will push a row in case module does not handle pushing
          * output rows.
+         *
          * @throws Exception
          */
         public void flush() throws Exception {
-            if (!manualPush) {
+            if (!pushOnFlush) {
                 notifyListener();
             }
         }

org.knime.scijava.commands/src/org/knime/scijava/commands/module/DefaultNodeModuleService.java renamed to org.knime.scijava.commands/src/org/knime/scijava/commands/module/AbstractNodeModuleService.java

@@ -1,9 +1,7 @@
 package org.knime.scijava.commands.module;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
@@ -19,7 +17,9 @@
 import org.knime.scijava.commands.settings.SettingsModelTypeService;
 import org.knime.scijava.commands.settings.models.SettingsModelColumnSelection;
 import org.knime.scijava.commands.settings.types.SettingsModelColumnSelectionType;
+import org.scijava.Context;
 import org.scijava.Identifiable;
+import org.scijava.command.CommandInfo;
 import org.scijava.module.ModuleInfo;
 import org.scijava.module.ModuleItem;
 import org.scijava.module.ModuleService;
@@ -33,7 +33,7 @@
  * @author Christian Dietz, University of Konstanz
  */
 @Plugin(type = NodeModuleService.class)
-public class DefaultNodeModuleService extends AbstractService
+public abstract class AbstractNodeModuleService extends AbstractService
         implements NodeModuleService {
 
     @Parameter
@@ -47,7 +47,7 @@ public class DefaultNodeModuleService extends AbstractService
 
     @Override
     public NodeModule createNodeModule(final ModuleInfo info,
-            final Map<String, SettingsModel> models, final DataTableSpec spec,
+            final Map<String, SettingsModel> models, final DataTableSpec inSpec,
             final NodeLogger knimeLogger) {
 
         final Map<Integer, ModuleItem<?>> inputMapping = new HashMap<>();
@@ -71,7 +71,7 @@ public NodeModule createNodeModule(final ModuleInfo info,
                 final SettingsModelColumnSelection settingsModel = (SettingsModelColumnSelection) models
                         .get(item.getName());
                 inputMapping.put(
-                        spec.findColumnIndex(settingsModel.getStringValue()),
+                        inSpec.findColumnIndex(settingsModel.getStringValue()),
                         item);
             } else {
                 @SuppressWarnings("unchecked")
@@ -80,11 +80,16 @@ public NodeModule createNodeModule(final ModuleInfo info,
             }
         }
 
-        return new DefaultNodeModule(getContext(), info, params, inputMapping,
-                outputMapping, knimeLogger);
-
+        return createNodeModule(getContext(), (CommandInfo) info, params,
+                inputMapping, outputMapping, knimeLogger);
     }
 
+    protected abstract NodeModule createNodeModule(final Context context,
+            final CommandInfo info, final Map<String, Object> params,
+            final Map<Integer, ModuleItem<?>> inputMapping,
+            final Map<ModuleItem<?>, DataType> outputMapping,
+            final NodeLogger knimeLogger);
+
     @Override
     public DataTableSpec createOutSpec(final ModuleInfo info,
             final Map<String, SettingsModel> models,
@@ -100,22 +105,14 @@ public DataTableSpec createOutSpec(final ModuleInfo info,
             nameGen = new UniqueNameGenerator(new HashSet<>());
         }
 
-        // TODO (What?)... What?
-        final List<DataColumnSpec> tableSpecs = new ArrayList<>();
-
-        // FIXME (result)
-        for (final ModuleItem<?> item : info.outputs()) {
-            if (item.getName().equals("result")) {
-                continue;
-            }
-            tableSpecs.add(
-                    nameGen.newColumn(item.getName(), outputMapping.get(item)));
-        }
-
         return new DataTableSpec(
-                tableSpecs.toArray(new DataColumnSpec[tableSpecs.size()]));
+                createOutColumnSpecs(info, outputMapping, nameGen));
     }
 
+    protected abstract DataColumnSpec[] createOutColumnSpecs(final ModuleInfo info,
+            final Map<ModuleItem<?>, DataType> outputMapping,
+            final UniqueNameGenerator nameGen);
+
     @Override
     public Map<ModuleItem<?>, DataType> getOutputMapping(final ModuleInfo info,
             final Map<String, SettingsModel> models) {

org.knime.scijava.commands/src/org/knime/scijava/commands/module/CommandNodeModule.java

@@ -0,0 +1,41 @@
+package org.knime.scijava.commands.module;
+
+import java.util.Map;
+
+import org.knime.core.data.DataType;
+import org.knime.core.node.NodeLogger;
+import org.scijava.Context;
+import org.scijava.command.CommandInfo;
+import org.scijava.module.ModuleItem;
+
+/**
+ * Default implementation of {@link NodeModule}.
+ *
+ * @author Christian Dietz, University of Konstanz
+ */
+class CommandNodeModule extends AbstractNodeModule {
+
+    /**
+     * Constructor.
+     *
+     * @param context
+     *            Scijava context.
+     * @param info
+     *            info of the command module this module is created for
+     * @param params
+     *            preresolved values for the parameters of the module
+     * @param inputMapping
+     *            mapping of input column index to input items of the module
+     * @param outputMapping
+     *            mapping of output items to types for the cells to for them
+     * @param logger
+     *            NodeLogger to delegate output to.
+     */
+    public CommandNodeModule(final Context context, final CommandInfo info,
+            final Map<String, Object> params,
+            final Map<Integer, ModuleItem<?>> inputMapping,
+            final Map<ModuleItem<?>, DataType> outputMapping,
+            final NodeLogger logger) {
+        super(context, info, params, inputMapping, outputMapping, logger);
+    }
+}

org.knime.scijava.commands/src/org/knime/scijava/commands/module/CommandNodeModuleService.java

@@ -0,0 +1,48 @@
+package org.knime.scijava.commands.module;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import org.knime.core.data.DataColumnSpec;
+import org.knime.core.data.DataType;
+import org.knime.core.node.NodeLogger;
+import org.knime.core.util.UniqueNameGenerator;
+import org.scijava.Context;
+import org.scijava.command.CommandInfo;
+import org.scijava.module.ModuleInfo;
+import org.scijava.module.ModuleItem;
+import org.scijava.plugin.Plugin;
+
+/**
+ * Default implementation of {@link NodeModuleService}.
+ *
+ * @author Christian Dietz, University of Konstanz
+ */
+@Plugin(type = NodeModuleService.class)
+public class CommandNodeModuleService extends AbstractNodeModuleService {
+
+    @Override
+    protected NodeModule createNodeModule(final Context context,
+            final CommandInfo info, final Map<String, Object> params,
+            final Map<Integer, ModuleItem<?>> inputMapping,
+            final Map<ModuleItem<?>, DataType> outputMapping,
+            final NodeLogger knimeLogger) {
+        return new CommandNodeModule(context, info, params, inputMapping,
+                outputMapping, knimeLogger);
+    }
+
+    @Override
+    protected DataColumnSpec[] createOutColumnSpecs(final ModuleInfo info,
+            final Map<ModuleItem<?>, DataType> outputMapping,
+            final UniqueNameGenerator nameGen) {
+        final ArrayList<DataColumnSpec> outSpecs = new ArrayList<>();
+
+        for (final ModuleItem<?> item : info.outputs()) {
+            outSpecs.add(
+                    nameGen.newColumn(item.getName(), outputMapping.get(item)));
+        }
+
+        return outSpecs.toArray(new DataColumnSpec[outSpecs.size()]);
+    }
+
+}