taverna-wsdl-activity-ui/src/main/java/net/sf/taverna/t2/activities/wsdl/actions/AddXMLSplitterEdit.java - incubator-taverna-workbench-common-activities - Git at Google

 /*******************************************************************************
  * Copyright (C) 2007 The University of Manchester
  *
  *  Modifications to the initial code base are copyright of their
  *  respective authors, or their employers as appropriate.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public License
  *  as published by the Free Software Foundation; either version 2.1 of
  *  the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful, but
  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  ******************************************************************************/
 package net.sf.taverna.t2.activities.wsdl.actions;

 import java.net.URI;
 import java.util.ArrayList;
 import java.util.List;

 import net.sf.taverna.t2.activities.wsdl.servicedescriptions.WSDLServiceDescription;
 import net.sf.taverna.t2.activities.wsdl.xmlsplitter.XMLSplitterConfigurationBeanBuilder;
 import net.sf.taverna.t2.workbench.edits.CompoundEdit;
 import net.sf.taverna.t2.workbench.edits.Edit;
 import net.sf.taverna.t2.workbench.edits.EditException;
 import net.sf.taverna.t2.workflow.edits.AddChildEdit;
 import net.sf.taverna.t2.workflow.edits.AddDataLinkEdit;
 import net.sf.taverna.t2.workflow.edits.AddProcessorEdit;
 import net.sf.taverna.wsdl.parser.ArrayTypeDescriptor;
 import net.sf.taverna.wsdl.parser.TypeDescriptor;
 import net.sf.taverna.wsdl.xmlsplitter.XMLSplitterSerialisationHelper;

 import org.jdom.Element;

 import uk.org.taverna.scufl2.api.activity.Activity;
 import uk.org.taverna.scufl2.api.common.Scufl2Tools;
 import uk.org.taverna.scufl2.api.configurations.Configuration;
 import uk.org.taverna.scufl2.api.core.DataLink;
 import uk.org.taverna.scufl2.api.core.Processor;
 import uk.org.taverna.scufl2.api.core.Workflow;
 import uk.org.taverna.scufl2.api.iterationstrategy.CrossProduct;
 import uk.org.taverna.scufl2.api.port.InputProcessorPort;
 import uk.org.taverna.scufl2.api.port.OutputProcessorPort;
 import uk.org.taverna.scufl2.api.profiles.ProcessorBinding;
 import uk.org.taverna.scufl2.api.profiles.Profile;

 import com.fasterxml.jackson.databind.JsonNode;

 public class AddXMLSplitterEdit implements Edit<Workflow> {

 	public static final URI INPUT_SPLITTER_TYPE = URI
 			.create("http://ns.taverna.org.uk/2010/activity/xml-splitter/in");
 	public static final URI OUTPUT_SPLITTER_TYPE = URI
 			.create("http://ns.taverna.org.uk/2010/activity/xml-splitter/out");
 	public static final URI SPLITTER_CONFIG_TYPE = URI
 			.create("http://ns.taverna.org.uk/2010/activity/xml-splitter#Config");

 	private Scufl2Tools scufl2Tools = new Scufl2Tools();

 	private final Workflow workflow;
 	private final Profile profile;
 	private final Activity activity;
 	private TypeDescriptor typeDescriptor;
 	private final String portName;
 	private final boolean isInput;

 	private CompoundEdit compoundEdit1 = null;
 	private Edit<?> linkUpEdit;
 	private boolean applied = false;

 	public AddXMLSplitterEdit(Workflow workflow, Profile profile, Activity activity,
 			TypeDescriptor typeDescriptor, String portName, boolean isInput) {
 		this.workflow = workflow;
 		this.profile = profile;
 		this.activity = activity;
 		this.typeDescriptor = typeDescriptor;
 		this.portName = portName;
 		this.isInput = isInput;
 	}

 	@Override
 	public Workflow doEdit() throws EditException {
 		if (applied) {
 			throw new EditException("Edit has already been applied!");
 		}

 		Activity splitter = null;
 		Configuration splitterConfiguration = null;
 		String sourcePortName = "";
 		Processor sourceProcessor = null;

 		String sinkPortName = "";
 		Processor sinkProcessor = null;

 		Processor activityProcessor = null;
 		List<ProcessorBinding> processorBindingsToActivity = scufl2Tools
 				.processorBindingsToActivity(activity);
 		for (ProcessorBinding processorBinding : processorBindingsToActivity) {
 			activityProcessor = processorBinding.getBoundProcessor();
 			break;
 		}
 		if (activityProcessor == null) {
 			throw new EditException("Cannot find the processor that the activity belongs to");
 		}

 		String displayName = portName;
 		if (portName.equals("parameters")) {
 			displayName = isInput ? "input" : "output";
 		}
 		String processorName = activityProcessor.getName();
 		String candidateName;
 		if (displayName.startsWith(processorName)) {
 			// No need to make GetRequest_GetRequestResponse
 			candidateName = displayName;
 		} else {
 			// Combine with processor name
 			String displayProcessorName;
 			if (activity.getType().equals(INPUT_SPLITTER_TYPE)
 					|| activity.getType().equals(OUTPUT_SPLITTER_TYPE)) {
 				// For splitters on splitters - avoid adding up blah_bluh_blih_more_stuff
 				String[] processorNameSplit = processorName.replace("_input", "")
 						.replace("_output", "").split("_");
 				displayProcessorName = processorNameSplit[processorNameSplit.length - 1];
 			} else {
 				displayProcessorName = activityProcessor.getName();
 			}
 			candidateName = displayProcessorName + "_" + displayName;
 		}

 		Processor splitterProcessor = new Processor();
 		splitterProcessor.setName(candidateName);

 		CrossProduct crossProduct = new CrossProduct();
 		crossProduct.setParent(splitterProcessor.getIterationStrategyStack());

 		ProcessorBinding processorBinding = new ProcessorBinding();
 		processorBinding.setBoundProcessor(splitterProcessor);

 		try {
 			if (activity.getType().equals(INPUT_SPLITTER_TYPE)) {
 				if (!isInput) {
 					throw new EditException(
 							"Can only add an input splitter to another input splitter");
 				}
 				if (typeDescriptor instanceof ArrayTypeDescriptor
 						&& !((ArrayTypeDescriptor) typeDescriptor).isWrapped()) {
 					typeDescriptor = ((ArrayTypeDescriptor) typeDescriptor).getElementType();
 				}

 				Element element = XMLSplitterSerialisationHelper
 						.typeDescriptorToExtensionXML(typeDescriptor);
 //				String wrappedType = new XMLOutputter().outputString(element);

 				splitter = new Activity();
 				splitter.setType(INPUT_SPLITTER_TYPE);
 				splitterConfiguration = new Configuration();
 				splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
 				splitterConfiguration.setConfigures(splitter);
 //				((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

 				JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForInput(element);
 				splitterConfiguration.setJson(bean);

 				XMLSplitterPortBuilder.addPortsForInput(element, splitter, splitterProcessor,
 						processorBinding);

 			} else if (activity.getType().equals(OUTPUT_SPLITTER_TYPE)) {
 				if (isInput) {
 					throw new EditException(
 							"Can only add an output splitter to another output splitter");
 				}
 				if (typeDescriptor instanceof ArrayTypeDescriptor
 						&& !((ArrayTypeDescriptor) typeDescriptor).isWrapped()) {
 					typeDescriptor = ((ArrayTypeDescriptor) typeDescriptor).getElementType();
 				}

 				Element element = XMLSplitterSerialisationHelper
 						.typeDescriptorToExtensionXML(typeDescriptor);
 //				String wrappedType = new XMLOutputter().outputString(element);

 				splitter = new Activity();
 				splitter.setType(OUTPUT_SPLITTER_TYPE);
 				splitterConfiguration = new Configuration();
 				splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
 				splitterConfiguration.setConfigures(splitter);
 //				((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

 				JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForOutput(element);
 				splitterConfiguration.setJson(bean);

 				XMLSplitterPortBuilder.addPortsForOutput(element, splitter, splitterProcessor,
 						processorBinding);

 			} else if (activity.getType().equals(WSDLServiceDescription.ACTIVITY_TYPE)) {
 				if (isInput) {
 					Element element = XMLSplitterSerialisationHelper
 							.typeDescriptorToExtensionXML(typeDescriptor);
 //					String wrappedType = new XMLOutputter().outputString(element);

 					splitter = new Activity();
 					splitter.setType(WSDLServiceDescription.INPUT_SPLITTER_TYPE);
 					splitterConfiguration = new Configuration();
 					splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
 					splitterConfiguration.setConfigures(splitter);
 //					((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

 					JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForInput(element);
 					splitterConfiguration.setJson(bean);

 					XMLSplitterPortBuilder.addPortsForInput(element, splitter, splitterProcessor,
 							processorBinding);

 				} else {
 					Element element = XMLSplitterSerialisationHelper
 							.typeDescriptorToExtensionXML(typeDescriptor);
 //					String wrappedType = new XMLOutputter().outputString(element);

 					splitter = new Activity();
 					splitter.setType(WSDLServiceDescription.OUTPUT_SPLITTER_TYPE);
 					splitterConfiguration = new Configuration();
 					splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
 					splitterConfiguration.setConfigures(splitter);
 //					((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

 					JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForOutput(element);
 					splitterConfiguration.setJson(bean);

 					XMLSplitterPortBuilder.addPortsForOutput(element, splitter, splitterProcessor,
 							processorBinding);
 				}
 			} else {
 				throw new EditException(
 						"The activity type is not suitable for adding xml processing processors");
 			}
 		} catch (Exception e) {
 			throw new EditException(
 					"An error occured whilst tyring to add an XMLSplitter to the activity:"
 							+ activity, e);
 		}

 		if (isInput) {
 			sourcePortName = "output";
 			sinkPortName = portName;
 			sinkProcessor = activityProcessor;
 			sourceProcessor = splitterProcessor;
 		} else {
 			sourcePortName = portName;
 			sinkPortName = "input";
 			sinkProcessor = splitterProcessor;
 			sourceProcessor = activityProcessor;
 		}

 		processorBinding.setBoundActivity(splitter);

 		List<Edit<?>> editList = new ArrayList<Edit<?>>();
 		editList.add(new AddChildEdit<Profile>(profile, splitter));
 		editList.add(new AddChildEdit<Profile>(profile, splitterConfiguration));
 		editList.add(new AddChildEdit<Profile>(profile, processorBinding));
 		editList.add(new AddProcessorEdit(workflow, splitterProcessor));

 		compoundEdit1 = new CompoundEdit(editList);
 		compoundEdit1.doEdit();

 		List<Edit<?>> linkUpEditList = new ArrayList<Edit<?>>();

 		OutputProcessorPort source = sourceProcessor.getOutputPorts().getByName(sourcePortName);
 		InputProcessorPort sink = sinkProcessor.getInputPorts().getByName(sinkPortName);

 		if (source == null)
 			throw new EditException("Unable to find the source port when linking up "
 					+ sourcePortName + " to " + sinkPortName);
 		if (sink == null)
 			throw new EditException("Unable to find the sink port when linking up "
 					+ sourcePortName + " to " + sinkPortName);

 		DataLink dataLink = new DataLink();
 		dataLink.setReceivesFrom(source);
 		dataLink.setSendsTo(sink);
 		linkUpEditList.add(new AddDataLinkEdit(workflow, dataLink));

 		linkUpEdit = new CompoundEdit(linkUpEditList);
 		linkUpEdit.doEdit();
 		applied = true;
 		return workflow;
 	}

 	@Override
 	public void undo() {
 		if (!applied) {
 			throw new RuntimeException("Attempt to undo edit that was never applied");
 		}
 		if (linkUpEdit.isApplied())
 			linkUpEdit.undo();
 		if (compoundEdit1.isApplied())
 			compoundEdit1.undo();
 		applied = false;
 	}

 	@Override
 	public boolean isApplied() {
 		return applied;
 	}

 	@Override
 	public Object getSubject() {
 		return workflow;
 	}

 }
	/*******************************************************************************
	* Copyright (C) 2007 The University of Manchester
	*
	* Modifications to the initial code base are copyright of their
	* respective authors, or their employers as appropriate.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public License
	* as published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	******************************************************************************/
	package net.sf.taverna.t2.activities.wsdl.actions;

	import java.net.URI;
	import java.util.ArrayList;
	import java.util.List;

	import net.sf.taverna.t2.activities.wsdl.servicedescriptions.WSDLServiceDescription;
	import net.sf.taverna.t2.activities.wsdl.xmlsplitter.XMLSplitterConfigurationBeanBuilder;
	import net.sf.taverna.t2.workbench.edits.CompoundEdit;
	import net.sf.taverna.t2.workbench.edits.Edit;
	import net.sf.taverna.t2.workbench.edits.EditException;
	import net.sf.taverna.t2.workflow.edits.AddChildEdit;
	import net.sf.taverna.t2.workflow.edits.AddDataLinkEdit;
	import net.sf.taverna.t2.workflow.edits.AddProcessorEdit;
	import net.sf.taverna.wsdl.parser.ArrayTypeDescriptor;
	import net.sf.taverna.wsdl.parser.TypeDescriptor;
	import net.sf.taverna.wsdl.xmlsplitter.XMLSplitterSerialisationHelper;

	import org.jdom.Element;

	import uk.org.taverna.scufl2.api.activity.Activity;
	import uk.org.taverna.scufl2.api.common.Scufl2Tools;
	import uk.org.taverna.scufl2.api.configurations.Configuration;
	import uk.org.taverna.scufl2.api.core.DataLink;
	import uk.org.taverna.scufl2.api.core.Processor;
	import uk.org.taverna.scufl2.api.core.Workflow;
	import uk.org.taverna.scufl2.api.iterationstrategy.CrossProduct;
	import uk.org.taverna.scufl2.api.port.InputProcessorPort;
	import uk.org.taverna.scufl2.api.port.OutputProcessorPort;
	import uk.org.taverna.scufl2.api.profiles.ProcessorBinding;
	import uk.org.taverna.scufl2.api.profiles.Profile;

	import com.fasterxml.jackson.databind.JsonNode;

	public class AddXMLSplitterEdit implements Edit<Workflow> {

	public static final URI INPUT_SPLITTER_TYPE = URI
	.create("http://ns.taverna.org.uk/2010/activity/xml-splitter/in");
	public static final URI OUTPUT_SPLITTER_TYPE = URI
	.create("http://ns.taverna.org.uk/2010/activity/xml-splitter/out");
	public static final URI SPLITTER_CONFIG_TYPE = URI
	.create("http://ns.taverna.org.uk/2010/activity/xml-splitter#Config");

	private Scufl2Tools scufl2Tools = new Scufl2Tools();

	private final Workflow workflow;
	private final Profile profile;
	private final Activity activity;
	private TypeDescriptor typeDescriptor;
	private final String portName;
	private final boolean isInput;

	private CompoundEdit compoundEdit1 = null;
	private Edit<?> linkUpEdit;
	private boolean applied = false;

	public AddXMLSplitterEdit(Workflow workflow, Profile profile, Activity activity,
	TypeDescriptor typeDescriptor, String portName, boolean isInput) {
	this.workflow = workflow;
	this.profile = profile;
	this.activity = activity;
	this.typeDescriptor = typeDescriptor;
	this.portName = portName;
	this.isInput = isInput;
	}

	@Override
	public Workflow doEdit() throws EditException {
	if (applied) {
	throw new EditException("Edit has already been applied!");
	}

	Activity splitter = null;
	Configuration splitterConfiguration = null;
	String sourcePortName = "";
	Processor sourceProcessor = null;

	String sinkPortName = "";
	Processor sinkProcessor = null;

	Processor activityProcessor = null;
	List<ProcessorBinding> processorBindingsToActivity = scufl2Tools
	.processorBindingsToActivity(activity);
	for (ProcessorBinding processorBinding : processorBindingsToActivity) {
	activityProcessor = processorBinding.getBoundProcessor();
	break;
	}
	if (activityProcessor == null) {
	throw new EditException("Cannot find the processor that the activity belongs to");
	}

	String displayName = portName;
	if (portName.equals("parameters")) {
	displayName = isInput ? "input" : "output";
	}
	String processorName = activityProcessor.getName();
	String candidateName;
	if (displayName.startsWith(processorName)) {
	// No need to make GetRequest_GetRequestResponse
	candidateName = displayName;
	} else {
	// Combine with processor name
	String displayProcessorName;
	if (activity.getType().equals(INPUT_SPLITTER_TYPE)
	\|\| activity.getType().equals(OUTPUT_SPLITTER_TYPE)) {
	// For splitters on splitters - avoid adding up blah_bluh_blih_more_stuff
	String[] processorNameSplit = processorName.replace("_input", "")
	.replace("_output", "").split("_");
	displayProcessorName = processorNameSplit[processorNameSplit.length - 1];
	} else {
	displayProcessorName = activityProcessor.getName();
	}
	candidateName = displayProcessorName + "_" + displayName;
	}

	Processor splitterProcessor = new Processor();
	splitterProcessor.setName(candidateName);

	CrossProduct crossProduct = new CrossProduct();
	crossProduct.setParent(splitterProcessor.getIterationStrategyStack());

	ProcessorBinding processorBinding = new ProcessorBinding();
	processorBinding.setBoundProcessor(splitterProcessor);

	try {
	if (activity.getType().equals(INPUT_SPLITTER_TYPE)) {
	if (!isInput) {
	throw new EditException(
	"Can only add an input splitter to another input splitter");
	}
	if (typeDescriptor instanceof ArrayTypeDescriptor
	&& !((ArrayTypeDescriptor) typeDescriptor).isWrapped()) {
	typeDescriptor = ((ArrayTypeDescriptor) typeDescriptor).getElementType();
	}

	Element element = XMLSplitterSerialisationHelper
	.typeDescriptorToExtensionXML(typeDescriptor);
	// String wrappedType = new XMLOutputter().outputString(element);

	splitter = new Activity();
	splitter.setType(INPUT_SPLITTER_TYPE);
	splitterConfiguration = new Configuration();
	splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
	splitterConfiguration.setConfigures(splitter);
	// ((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

	JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForInput(element);
	splitterConfiguration.setJson(bean);

	XMLSplitterPortBuilder.addPortsForInput(element, splitter, splitterProcessor,
	processorBinding);

	} else if (activity.getType().equals(OUTPUT_SPLITTER_TYPE)) {
	if (isInput) {
	throw new EditException(
	"Can only add an output splitter to another output splitter");
	}
	if (typeDescriptor instanceof ArrayTypeDescriptor
	&& !((ArrayTypeDescriptor) typeDescriptor).isWrapped()) {
	typeDescriptor = ((ArrayTypeDescriptor) typeDescriptor).getElementType();
	}

	Element element = XMLSplitterSerialisationHelper
	.typeDescriptorToExtensionXML(typeDescriptor);
	// String wrappedType = new XMLOutputter().outputString(element);

	splitter = new Activity();
	splitter.setType(OUTPUT_SPLITTER_TYPE);
	splitterConfiguration = new Configuration();
	splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
	splitterConfiguration.setConfigures(splitter);
	// ((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

	JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForOutput(element);
	splitterConfiguration.setJson(bean);

	XMLSplitterPortBuilder.addPortsForOutput(element, splitter, splitterProcessor,
	processorBinding);

	} else if (activity.getType().equals(WSDLServiceDescription.ACTIVITY_TYPE)) {
	if (isInput) {
	Element element = XMLSplitterSerialisationHelper
	.typeDescriptorToExtensionXML(typeDescriptor);
	// String wrappedType = new XMLOutputter().outputString(element);

	splitter = new Activity();
	splitter.setType(WSDLServiceDescription.INPUT_SPLITTER_TYPE);
	splitterConfiguration = new Configuration();
	splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
	splitterConfiguration.setConfigures(splitter);
	// ((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

	JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForInput(element);
	splitterConfiguration.setJson(bean);

	XMLSplitterPortBuilder.addPortsForInput(element, splitter, splitterProcessor,
	processorBinding);

	} else {
	Element element = XMLSplitterSerialisationHelper
	.typeDescriptorToExtensionXML(typeDescriptor);
	// String wrappedType = new XMLOutputter().outputString(element);

	splitter = new Activity();
	splitter.setType(WSDLServiceDescription.OUTPUT_SPLITTER_TYPE);
	splitterConfiguration = new Configuration();
	splitterConfiguration.setType(SPLITTER_CONFIG_TYPE);
	splitterConfiguration.setConfigures(splitter);
	// ((ObjectNode) splitterConfiguration.getJson()).put("wrappedType", wrappedType);

	JsonNode bean = XMLSplitterConfigurationBeanBuilder.buildBeanForOutput(element);
	splitterConfiguration.setJson(bean);

	XMLSplitterPortBuilder.addPortsForOutput(element, splitter, splitterProcessor,
	processorBinding);
	}
	} else {
	throw new EditException(
	"The activity type is not suitable for adding xml processing processors");
	}
	} catch (Exception e) {
	throw new EditException(
	"An error occured whilst tyring to add an XMLSplitter to the activity:"
	+ activity, e);
	}

	if (isInput) {
	sourcePortName = "output";
	sinkPortName = portName;
	sinkProcessor = activityProcessor;
	sourceProcessor = splitterProcessor;
	} else {
	sourcePortName = portName;
	sinkPortName = "input";
	sinkProcessor = splitterProcessor;
	sourceProcessor = activityProcessor;
	}

	processorBinding.setBoundActivity(splitter);

	List<Edit<?>> editList = new ArrayList<Edit<?>>();
	editList.add(new AddChildEdit<Profile>(profile, splitter));
	editList.add(new AddChildEdit<Profile>(profile, splitterConfiguration));
	editList.add(new AddChildEdit<Profile>(profile, processorBinding));
	editList.add(new AddProcessorEdit(workflow, splitterProcessor));

	compoundEdit1 = new CompoundEdit(editList);
	compoundEdit1.doEdit();

	List<Edit<?>> linkUpEditList = new ArrayList<Edit<?>>();

	OutputProcessorPort source = sourceProcessor.getOutputPorts().getByName(sourcePortName);
	InputProcessorPort sink = sinkProcessor.getInputPorts().getByName(sinkPortName);

	if (source == null)
	throw new EditException("Unable to find the source port when linking up "
	+ sourcePortName + " to " + sinkPortName);
	if (sink == null)
	throw new EditException("Unable to find the sink port when linking up "
	+ sourcePortName + " to " + sinkPortName);

	DataLink dataLink = new DataLink();
	dataLink.setReceivesFrom(source);
	dataLink.setSendsTo(sink);
	linkUpEditList.add(new AddDataLinkEdit(workflow, dataLink));

	linkUpEdit = new CompoundEdit(linkUpEditList);
	linkUpEdit.doEdit();
	applied = true;
	return workflow;
	}

	@Override
	public void undo() {
	if (!applied) {
	throw new RuntimeException("Attempt to undo edit that was never applied");
	}
	if (linkUpEdit.isApplied())
	linkUpEdit.undo();
	if (compoundEdit1.isApplied())
	compoundEdit1.undo();
	applied = false;
	}

	@Override
	public boolean isApplied() {
	return applied;
	}

	@Override
	public Object getSubject() {
	return workflow;
	}

	}