Merge pull request #10 from knime-ip/statelessness

makes sense! It also simplifies to code I think.

Thank you!

Author: dietzc

org.knime.knip.scijava.commands.testing/src/org/knime/knip/scijava/commands/testing/KnimeProcessorTest.java

@@ -26,8 +26,8 @@
 import org.knime.core.data.def.LongCell;
 import org.knime.core.data.def.StringCell;
 import org.knime.knip.scijava.commands.DefaultKnimePostprocessor;
-import org.knime.knip.scijava.commands.KnimeInputDataTableService;
-import org.knime.knip.scijava.commands.KnimeOutputDataTableService;
+import org.knime.knip.scijava.commands.KNIMEInputDataTableService;
+import org.knime.knip.scijava.commands.KNIMEOutputDataTableService;
 import org.knime.knip.scijava.commands.adapter.InputAdapterService;
 import org.knime.knip.scijava.commands.adapter.OutputAdapterService;
 import org.knime.knip.scijava.commands.mapping.ColumnInputMappingKnimePreprocessor;
@@ -57,14 +57,14 @@ public class KnimeProcessorTest {
 	@Parameter
 	CommandService m_commandService;
 	@Parameter
-	KnimeInputDataTableService m_inputTableService;
+	KNIMEInputDataTableService m_inputTableService;
 	@Parameter
-	KnimeOutputDataTableService m_outputTableService;
+	KNIMEOutputDataTableService m_outputTableService;
 	@Parameter
 	ColumnModuleItemMappingService m_cimService;
 
 	protected static List<Class<? extends Service>> requiredServices = Arrays.<Class<? extends Service>> asList(
-			KnimeInputDataTableService.class, KnimeOutputDataTableService.class, CommandService.class,
+			KNIMEInputDataTableService.class, KNIMEOutputDataTableService.class, CommandService.class,
 			ColumnModuleItemMappingService.class, InputAdapterService.class, OutputAdapterService.class);
 
 	private static final DataTableSpec m_spec;

org.knime.knip.scijava.commands/META-INF/MANIFEST.MF

@@ -30,3 +30,4 @@ Export-Package: org.knime.knip.scijava.commands,
  org.knime.knip.scijava.commands.settings.types,
  org.knime.knip.scijava.commands.widget,
  org.knime.knip.scijava.commands.widget.impl
+Import-Package: org.slf4j

org.knime.knip.scijava.commands/src/org/knime/knip/scijava/commands/DefaultInputDataRowService.java

@@ -1,52 +1,56 @@
 package org.knime.knip.scijava.commands;
 
+import java.lang.ref.WeakReference;
+
 import org.knime.core.data.DataRow;
 import org.knime.core.data.DataTableSpec;
 import org.scijava.Priority;
 import org.scijava.plugin.Plugin;
 import org.scijava.service.AbstractService;
 
 /**
- * Default implementation of InputDataRowService.
+ * Default implementation of InputDataRowService. Holds a {@link DataRow} and a
+ * {@link DataTableSpec} via a {@link WeakReference} to ensure that they can be
+ * garbage collected once they are not referenced outside this Service.
  * 
  * @author Jonathan Hale (University of Konstanz)
- * 
  */
 @Plugin(type = InputDataRowService.class, priority = DefaultInputDataRowService.PRIORITY)
-public class DefaultInputDataRowService extends AbstractService implements
-		InputDataRowService {
-	
+public class DefaultInputDataRowService extends AbstractService
+		implements InputDataRowService {
+
 	/**
 	 * Priority of this {@link Plugin}
 	 */
 	public static final double PRIORITY = Priority.NORMAL_PRIORITY;
 
-	private DataRow m_row = null;
-	private DataTableSpec m_spec = null;
+	private WeakReference<DataRow> m_row = new WeakReference<>(null);
+	private WeakReference<DataTableSpec> m_spec = new WeakReference<>(null);
 
 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public DataRow getInputDataRow() {
-		return m_row;
+		return m_row.get();
 	}
 
 	/**
 	 * Set the contained DataRow;
+	 * 
 	 * @param dataRow
 	 */
-	public void setDataRow(DataRow dataRow) {
-		m_row = dataRow;
+	public void setDataRow(final DataRow dataRow) {
+		m_row = new WeakReference<>(dataRow);
 	}
 
 	@Override
 	public DataTableSpec getInputDataTableSpec() {
-		return m_spec;
+		return m_spec.get();
 	}
-	
-	public void setDataTableSpec(DataTableSpec spec) {
-		m_spec = spec;
+
+	public void setDataTableSpec(final DataTableSpec spec) {
+		m_spec = new WeakReference<>(spec);
 	}
-	
+
 }

org.knime.knip.scijava.commands/src/org/knime/knip/scijava/commands/DefaultKNIMEScijavaContext.java

@@ -0,0 +1,117 @@
+package org.knime.knip.scijava.commands;
+
+import org.knime.knip.scijava.commands.adapter.InputAdapterService;
+import org.knime.knip.scijava.commands.adapter.OutputAdapterService;
+import org.knime.knip.scijava.commands.mapping.ColumnToInputMappingService;
+import org.knime.knip.scijava.commands.mapping.OutputToColumnMappingService;
+import org.knime.knip.scijava.commands.settings.NodeSettingsService;
+import org.knime.knip.scijava.commands.settings.SettingsModelTypeService;
+import org.scijava.Context;
+import org.scijava.plugin.Parameter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Default implementation of {@link KNIMEScijavaContext}. Enables convenient
+ * access to the KNIME related services in a Scijava Context.
+ * 
+ * @author Jonathan Hale (University of Konstanz)
+ */
+public class DefaultKNIMEScijavaContext implements KNIMEScijavaContext {
+
+	private Logger m_log = LoggerFactory.getLogger(getClass());
+
+	@Parameter
+	private Context m_context;
+
+	@Parameter
+	private InputAdapterService inputAdapterService;
+	@Parameter
+	private OutputAdapterService outputAdapterService;
+	@Parameter
+	private KNIMEInputDataTableService inputTableService;
+	@Parameter
+	private KNIMEOutputDataTableService outputTableService;
+	@Parameter
+	private ColumnToInputMappingService inputMappingService;
+	@Parameter
+	private OutputToColumnMappingService outputMappingService;
+	@Parameter
+	private SettingsModelTypeService settingsModelTypesService;
+	@Parameter
+	private NodeSettingsService nodeSettingsService;
+	@Parameter
+	private KNIMEExecutionService executionService;
+
+	@Override
+	public Context context() {
+		return m_context;
+	}
+
+	@Override
+	public Context getContext() {
+		return context();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 * 
+	 * @throws IllegalArgumentException
+	 *             If a service is missing
+	 */
+	@Override
+	public void setContext(Context context) throws IllegalArgumentException {
+		if (m_context == context) {
+			m_log.warn(
+					"CODING PROBLEM - Scijava context set mutiple times. Should only be set once.");
+			return;
+		}
+		context.inject(this);
+	}
+
+	@Override
+	public InputAdapterService inputAdapters() {
+		return inputAdapterService;
+	}
+
+	@Override
+	public OutputAdapterService outputAdapters() {
+		return outputAdapterService;
+	}
+
+	@Override
+	public KNIMEInputDataTableService inputTable() {
+		return inputTableService;
+	}
+
+	@Override
+	public KNIMEOutputDataTableService outputTable() {
+		return outputTableService;
+	}
+
+	@Override
+	public ColumnToInputMappingService inputMapping() {
+		return inputMappingService;
+	}
+
+	@Override
+	public OutputToColumnMappingService outputMapping() {
+		return outputMappingService;
+	}
+
+	@Override
+	public SettingsModelTypeService settingsModelTypes() {
+		return settingsModelTypesService;
+	}
+
+	@Override
+	public NodeSettingsService nodeSettings() {
+		return nodeSettingsService;
+	}
+
+	@Override
+	public KNIMEExecutionService execution() {
+		return executionService;
+	}
+
+}

org.knime.knip.scijava.commands/src/org/knime/knip/scijava/commands/DefaultKnimeExecutionService.java

@@ -1,34 +1,47 @@
 package org.knime.knip.scijava.commands;
 
+import java.lang.ref.WeakReference;
+
 import org.knime.core.node.ExecutionContext;
 import org.scijava.Priority;
 import org.scijava.plugin.Plugin;
 import org.scijava.service.AbstractService;
 
 /**
- * Default implementation of KnimeExecutionService.
+ * Default implementation of KnimeExecutionService. Holds a KNIME Node
+ * {@link ExecutionContext} in a {@link WeakReference}, which ensures that the
+ * {@link ExecutionContext} can be garbage collected when execution of a Node
+ * terminates.
  * 
  * @author Jonathan Hale (University of Konstanz)
- * 
+ * @see ExecutionContext
  */
-@Plugin(type = KnimeExecutionService.class, priority = DefaultKnimeExecutionService.PRIORITY)
-public class DefaultKnimeExecutionService extends AbstractService implements
-		KnimeExecutionService {
+@Plugin(type = KNIMEExecutionService.class, priority = DefaultKnimeExecutionService.PRIORITY)
+public class DefaultKnimeExecutionService extends AbstractService
+		implements KNIMEExecutionService {
 
 	/**
 	 * Priority of this {@link Plugin}
 	 */
 	public static final double PRIORITY = Priority.NORMAL_PRIORITY;
 
-	private ExecutionContext m_exec = null;
+	private WeakReference<ExecutionContext> m_exec = new WeakReference<>(null);
 
-	public void setExecutionContex(ExecutionContext e) {
-		m_exec = e;
+	/**
+	 * Set the {@link ExecutionContext}. Note that this service holds the
+	 * {@link ExecutionContext} in a {@link WeakReference}, which means that the
+	 * reference needs to be kept valid outside the service.
+	 * 
+	 * @param context
+	 */
+	@Override
+	public void setExecutionContext(final ExecutionContext context) {
+		m_exec = new WeakReference<>(context);
 	}
-	
+
 	@Override
 	public ExecutionContext getExecutionContext() {
-		return m_exec;
+		return m_exec.get();
 	}
 
 }

org.knime.knip.scijava.commands/src/org/knime/knip/scijava/commands/DefaultOutputDataRowService.java

@@ -1,41 +1,45 @@
 package org.knime.knip.scijava.commands;
 
+import java.lang.ref.WeakReference;
+
 import org.knime.core.data.DataRow;
 import org.scijava.Priority;
 import org.scijava.plugin.Plugin;
 import org.scijava.service.AbstractService;
 
 /**
- * Default implementation of OutputDataRowService.
+ * Default implementation of OutputDataRowService. Holds a {@link WeakReference}
+ * to a {@link DataRow} to ensure that it can be garbage collected once the
+ * {@link DataRow} is not referenced outside of this service.
  * 
  * @author Jonathan Hale (University of Konstanz)
  * 
  */
 @Plugin(type = OutputDataRowService.class, priority = DefaultOutputDataRowService.PRIORITY)
-public class DefaultOutputDataRowService extends AbstractService implements
-		OutputDataRowService {
+public class DefaultOutputDataRowService extends AbstractService
+		implements OutputDataRowService {
 
 	/**
 	 * Priority of this {@link Plugin}
 	 */
 	public static final double PRIORITY = Priority.NORMAL_PRIORITY;
 
-	private DataRow m_row = null;
+	private WeakReference<DataRow> m_row = new WeakReference<>(null);
 
 	/**
-	 *{@inheritDoc}
+	 * {@inheritDoc}
 	 */
 	@Override
 	public void setOutputDataRow(DataRow r) {
-		m_row = r;
+		m_row = new WeakReference<>(r);
 	}
 
 	/**
-	 *{@inheritDoc}
+	 * {@inheritDoc}
 	 */
 	@Override
 	public DataRow getOutputDataRow() {
-		return m_row;
+		return m_row.get();
 	}
 
 }

org.knime.knip.scijava.commands/src/org/knime/knip/scijava/commands/KnimeExecutionService.java renamed to org.knime.knip.scijava.commands/src/org/knime/knip/scijava/commands/KNIMEExecutionService.java

@@ -10,14 +10,23 @@
  * <p>
  * KnimeExecutionService plugins discoverable at runtime must implement this
  * interface and be annotated with @{@link Plugin} with attribute
- * {@link Plugin#type()} = {@link KnimeExecutionService}.class.
+ * {@link Plugin#type()} = {@link KNIMEExecutionService}.class.
  * </p>
  * 
  * @author Jonathan Hale (University of Konstanz)
  * 
  */
-public interface KnimeExecutionService extends Service {
+public interface KNIMEExecutionService extends Service {
 
+	/**
+	 * @return the ExecutionContext held by this service, or null if there is
+	 *         none.
+	 */
 	ExecutionContext getExecutionContext();
 
+	/**
+	 * Set the ExecutionContext for this service to hold.
+	 */
+	void setExecutionContext(ExecutionContext context);
+
 }