import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
public Dataflow getDataflow(Workflow workflow)
		throws InvalidWorkflowException {
	if (!workflowToDataflow.containsKey(workflow)) {
		try {
			Dataflow dataflow = createDataflow(workflow);
			workflowToDataflow.put(workflow, dataflow);
			dataflowToWorkflow.put(dataflow, workflow);
		} catch (EditException | ActivityConfigurationException
				| DispatchLayerConfigurationException
				| ActivityNotFoundException
				| DispatchLayerNotFoundException e) {
			throw new InvalidWorkflowException(e);
		}
	}
	return workflowToDataflow.get(workflow);
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
@Override
protected Component createCustomComponent() {
	Workflow workflow = (Workflow) getContextualSelection().getParent();
	Profile profile = workflow.getParent().getMainProfile();
	Port port = getSelectedPort();
	// Component component =
	// getContextualSelection().getRelativeToComponent();

	String label;
	if (port instanceof ReceiverPort) {
		label = CONNECT_WITH_OUTPUT_FROM;
	} else {
		label = CONNECT_AS_INPUT_TO;
	}
	JMenu connectMenu = new JMenu(new DummyAction(label,
			WorkbenchIcons.datalinkIcon));
	addPortMenuItems(workflow, port, connectMenu);
	addProcessorMenuItems(workflow, profile, port, connectMenu);
	return connectMenu;
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
private void checkOneConfiguration(InputWorkflowPort workflowPort,
		Integer depth, Workflow workflow, WorkflowBundle workflowBundle,
		Activity activity, Configuration c) {
	JsonNode nested = c.getJson().get("nestedWorkflow");
	Workflow nestedWorkflow = workflowBundle.getWorkflows().getByName(
			nested.asText());
	if (nestedWorkflow != workflow)
		return;

	ActivityPort activityPort = activity.getInputPorts().getByName(
			workflowPort.getName());
	activityPort.setDepth(depth);
	for (ProcessorBinding binding : scufl2Tools
			.processorBindingsToActivity(activity))
		for (ProcessorInputPortBinding portBinding : binding
				.getInputPortBindings())
			if (portBinding.getBoundActivityPort() == activityPort) {
				InputProcessorPort processorPort = portBinding
						.getBoundProcessorPort();
				processorPort.setDepth(depth);
			}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
@Test
public void workflowWithoutRevisions() throws Exception {
	URL wfResource = getClass().getResource(WF_RANDOM);
	assertNotNull("Could not find workflow " + WF_RANDOM, wfResource);
	T2FlowParser parser = new T2FlowParser();
	parser.setValidating(true);
	parser.setStrict(true);
	WorkflowBundle wfBundle = parser.parseT2Flow(wfResource.openStream());
	List<String> expectedRevisions = Arrays.asList(
			"e87de19a-02c7-4106-ae81-0b8e28efb22c");

	List<String> foundRevisions = new ArrayList<String>();

	Revision revision = wfBundle.getMainWorkflow().getCurrentRevision();
	while (revision != null) {
		URI revisionUri = revision.getIdentifier();
		String revisionUUID = uriTools
				.relativePath(Workflow.WORKFLOW_ROOT, revisionUri)
				.toASCIIString().replace("/", "");
		foundRevisions.add(revisionUUID);
		revision = revision.getPreviousRevision();
	}
	assertEquals(expectedRevisions, foundRevisions);

}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
public WorkflowReport generateWorkflowReport(Workflow workflow) {
	WorkflowReport workflowReport = createWorkflowReport(workflow);
	for (Processor processor : workflow.getProcessors()) {
		ProcessorReport processorReport = createProcessorReport(processor);
		processorReport.setParentReport(workflowReport);
		workflowReport.addProcessorReport(processorReport);
		for (ProcessorBinding processorBinding : scufl2Tools.processorBindingsForProcessor(
				processor, profile)) {
			Activity boundActivity = processorBinding.getBoundActivity();
			ActivityReport activityReport = createActivityReport(boundActivity);
			activityReport.setParentReport(processorReport);
			if (scufl2Tools.containsNestedWorkflow(processor, profile)) {
				Workflow nestedWorkflow = scufl2Tools.nestedWorkflowForProcessor(processor,
						profile);
				WorkflowReport nestedWorkflowReport = generateWorkflowReport(nestedWorkflow);
				nestedWorkflowReport.setParentReport(activityReport);
				activityReport.setNestedWorkflowReport(nestedWorkflowReport);
			}
			processorReport.addActivityReport(activityReport);
		}
	}
	return workflowReport;
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
/**
 * @throws java.lang.Exception
 */
@Before
public void setUp() throws Exception {
	workflow = new Workflow();
	mainWorkflow = new Workflow();
	profile = new Profile();
	mainProfile = new Profile();
	workflowBundle = new WorkflowBundle();
	workflowBundle.setMainProfile(mainProfile);
	workflowBundle.setMainWorkflow(mainWorkflow);
	executionService = new LocalExecutionService();
	executionEnvironment = new LocalExecutionEnvironment(executionService, null, null);

	dataBundle = DataBundles.createBundle();
	runProfile = new RunProfile(executionEnvironment, workflowBundle, workflow.getName(), profile.getName(), dataBundle);
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
protected WorkflowReport parseWorkflowReport(JsonNode reportJson,
		Path workflowReportJson, ActivityReport actReport,
		WorkflowBundle workflowBundle) throws ParseException {
	Workflow wf = (Workflow) getSubject(reportJson, workflowBundle);
	WorkflowReport workflowReport = new WorkflowReport(wf);
	workflowReport.setParentReport(actReport);

	parseDates(reportJson, workflowReport);

	for (JsonNode invocJson : reportJson.path("invocations"))
		// NOTE: Invocation constructor will add to parents
		parseInvocation(invocJson, workflowReportJson, workflowReport);

	for (JsonNode procJson : reportJson.path("processorReports")) {
		ProcessorReport procReport = parseProcessorReport(procJson,
				workflowReportJson, workflowReport, workflowBundle);
		workflowReport.addProcessorReport(procReport);
	}
	return workflowReport;
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
public WorkflowBundle parseScufl(ScuflType wf) throws ReaderException,
		JAXBException {
	try {
		parserState.get().setCurrentParser(this);
		WorkflowBundle wfBundle = new WorkflowBundle();
		parserState.get().setCurrentWorkflowBundle(wfBundle);
		makeProfile(wf);
		Workflow w = parseWorkflow(wf);
		wfBundle.setMainWorkflow(w);

		scufl2Tools.setParents(wfBundle);

		return wfBundle;
	} finally {
		parserState.remove();
	}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
private void considerEdit(EditManagerEvent message, Edit<?> edit) {
	// boolean result = false;
	if (edit instanceof CompoundEdit) {
		for (Edit<?> subEdit : ((CompoundEdit) edit).getChildEdits())
			considerEdit(message, subEdit);
		return;
	}

	Object subject = edit.getSubject();
	if (subject == owningProcessor) {
		// panel.reevaluate();
		setTitle(getRelativeName(owningWorkflowBundle, activity));
	} else if (subject == owningWorkflowBundle) {
		for (Workflow workflow : owningWorkflowBundle.getWorkflows())
			if (!workflow.getProcessors().contains(owningProcessor))
				clearDialog(activity);
	} else if (subject == activity) {
		if (message instanceof DataFlowUndoEvent) {
			logger.info("undo of activity edit found");
			panel.refreshConfiguration();
		} else if (message instanceof DataFlowRedoEvent) {
			logger.info("redo of activity edit found");
			panel.refreshConfiguration();
		}
	}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void expectedOrder() throws Exception {

	Workflow wf = new Workflow();		
	wf.setName("wf");
	
	Processor a = new Processor(wf, "a");
	Processor b = new Processor(wf, "b");
	Processor c = new Processor(wf, "c");
	Processor d = new Processor(wf, "d");

	BlockingControlLink b_blocks_c = new BlockingControlLink(c, b);
	BlockingControlLink a_blocks_c = new BlockingControlLink(c, a);
	BlockingControlLink a_blocks_b = new BlockingControlLink(b, a);
	BlockingControlLink b_blocks_d = new BlockingControlLink(d, b);
	BlockingControlLink a_blocks_d = new BlockingControlLink(d, a);
	
	ArrayList<ControlLink> links = new ArrayList<ControlLink>(wf.getControlLinks());
	assertEquals(Arrays.asList(a_blocks_b, a_blocks_c, a_blocks_d, b_blocks_c, b_blocks_d), links);
	Collections.shuffle(links);
	Collections.sort(links);
	assertEquals(Arrays.asList(a_blocks_b, a_blocks_c, a_blocks_d, b_blocks_c, b_blocks_d), links);
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
@Test
public void mergeAbcAndPIntoNew() throws Exception {
	Workflow merged = new Workflow();
	DataflowMerger merger = new DataflowMerger(merged);
	merger.getMergeEdit(abc).doEdit();

	assertNotSame(abc, merged);
	merger.getMergeEdit(p).doEdit();


	// Assert abc and p were not modified
	checkAbc();
	checkP();

	checkMergedAbcP(merged);
	checkCopiedFromP(merged);
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
/**
 * Create a new WorkflowBundle with a default workflow and profile.
 * <p>
 * Unlike the {@link WorkflowBundle} constructor, this method will also make
 * a {@link WorkflowBundle#getMainWorkflow()} and
 * {@link WorkflowBundle#getMainProfile()}, simplifying construction of
 * workflow bundles from scratch.
 * <p>
 * Each of the bundle, workflow and profile will also have a revision set
 * using {@link Revisioned#newRevision()} and their names set to short
 * default values.
 * 
 * @return A template {@link WorkflowBundle} which has a main workflow and
 *         main profile
 */
public WorkflowBundle createBundle() {
	WorkflowBundle wb = new WorkflowBundle();
	wb.setName("bundle1");

	Workflow workflow = new Workflow();
	workflow.setName("workflow1");
	workflow.setParent(wb);
	workflow.newRevision();

	Profile profile = new Profile();
	profile.setName("profile1");
	profile.setParent(wb);
	profile.newRevision();

	wb.setMainWorkflow(workflow);
	wb.setMainProfile(profile);
	wb.newRevision();
	return wb;
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
private void defineEditsForConfiguration(Workflow workflow,
		OutputWorkflowPort port, WorkflowBundle workflowBundle,
		Activity activity, Configuration c) {
	List<Edit<?>> edits = nestedPortEdit.getChildEdits();
	JsonNode nested = c.getJson().get("nestedWorkflow");
	Workflow nestedWorkflow = workflowBundle.getWorkflows().getByName(
			nested.asText());
	if (nestedWorkflow != workflow)
		return;

	OutputActivityPort activityPort = activity.getOutputPorts().getByName(
			port.getName());
	edits.add(new RemoveChildEdit<>(activity, activityPort));
	for (ProcessorBinding processorBinding : scufl2Tools
			.processorBindingsToActivity(activity))
		for (ProcessorOutputPortBinding portBinding : processorBinding
				.getOutputPortBindings())
			if (portBinding.getBoundActivityPort() == activityPort) {
				OutputProcessorPort processorPort = portBinding
						.getBoundProcessorPort();
				edits.add(new RemoveProcessorOutputPortEdit(
						processorBinding.getBoundProcessor(), processorPort));
				edits.add(new RemoveChildEdit<>(processorBinding,
						portBinding));
			}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
protected void assertHasOutputPorts(Workflow dataflow,
		String... expectedOutputPorts) {
	Set<String> expectedNames = new HashSet<String>();
	for (String expected : expectedOutputPorts) {
		expectedNames.add(expected);
	}
	Set<String> foundNames = new HashSet<String>();
	for (OutputWorkflowPort port : dataflow.getOutputPorts()) {
		String name = port.getName();
		foundNames.add(name);
	}

	Set<String> extras = new HashSet<String>(foundNames);
	extras.removeAll(expectedNames);
	assertTrue("Unexpected output port  " + extras, extras.isEmpty());

	Set<String> missing = new HashSet<String>(expectedNames);
	missing.removeAll(foundNames);
	assertTrue("Could not find output port  " + missing, missing.isEmpty());
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
public GraphController(Workflow workflow, Profile profile,
		boolean interactive, Component componentForPopups,
		Alignment alignment, PortStyle portStyle, EditManager editManager,
		MenuManager menuManager, ColourManager colourManager) {
	this.workflow = workflow;
	this.profile = profile;
	this.interactive = interactive;
	this.componentForPopups = componentForPopups;
	this.alignment = alignment;
	this.portStyle = portStyle;
	this.editManager = editManager;
	this.colourManager = colourManager;
	this.graphEventManager = new DefaultGraphEventManager(this,
			componentForPopups, menuManager);
	graph = generateGraph();
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
protected JsonNode toJson(Processor proc) {
	ObjectNode p = mapper.createObjectNode();
	p.putPOJO("id",
			uriTools.relativeUriForBean(proc, proc.getParent().getParent()));
	p.put("name", proc.getName());
	addPorts(proc, p);
	p.putAll(annotations(proc));

	List<Workflow> nested = scufl2Tools.nestedWorkflowsForProcessor(proc,
			proc.getParent().getParent().getMainProfile());
	if (!nested.isEmpty()) {
		if (nested.size() == 1) {
			p.put("nestedWorkflow", toJson(nested.iterator().next()));
		} else {
			ArrayNode list = mapper.createArrayNode();
			for (Workflow w : nested) {
				list.add(toJson(w));
			}
			p.put("nestedWorkflow", list);
		}
	}
	return p;
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
@Test
public void testCorrectnessOfMergePositionSpecifiedCorrectly() {
	Workflow w = new Workflow();
	DataLink dataLink = new DataLink();
	dataLink.setParent(w);
	
	InputWorkflowPort iwp = new InputWorkflowPort();
	iwp.setParent(w);
	
	OutputWorkflowPort owp = new OutputWorkflowPort();
	owp.setParent(w);
	
	dataLink.setReceivesFrom(iwp);
	dataLink.setSendsTo(owp);
	
	Integer mergePosition = Integer.valueOf(3);
	dataLink.setMergePosition(mergePosition);
	
	CorrectnessValidator cv = new CorrectnessValidator();
	ReportCorrectnessValidationListener rcvl = new ReportCorrectnessValidationListener();
			
	cv.checkCorrectness(dataLink, false, rcvl);
	
	Set<NegativeValueProblem> negativeValueProblems = rcvl.getNegativeValueProblems();
	assertEquals(Collections.EMPTY_SET, negativeValueProblems);
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
protected Set<Processor> findProcessors(Workflow dataflow, Port targetPort) {
	Set<Processor> possibleProcessors = new HashSet<Processor>();
	if (targetPort instanceof InputProcessorPort) {
		InputProcessorPort inputProcessorPort = (InputProcessorPort) targetPort;
		possibleProcessors = scufl2Tools.possibleUpStreamProcessors(dataflow, inputProcessorPort.getParent());
	} else if (targetPort instanceof OutputProcessorPort) {
		OutputProcessorPort outputProcessorPort = (OutputProcessorPort) targetPort;
		possibleProcessors = scufl2Tools.possibleDownStreamProcessors(dataflow, outputProcessorPort.getParent());
	} else {
		// Probably a dataflow port, everything is allowed
		possibleProcessors = dataflow.getProcessors();
	}
	return possibleProcessors;
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
private void addControlLinks(Workflow workflow) throws EditException {
	for (ControlLink controlLink : workflow.getControlLinks()) {
		if (controlLink instanceof BlockingControlLink) {
			BlockingControlLink blockingControlLink = (BlockingControlLink) controlLink;
			Processor untilFinished = blockingControlLink
					.getUntilFinished();
			Processor block = blockingControlLink.getBlock();
			edits.getCreateConditionEdit(
					workflowToDataflowProcessors.get(untilFinished),
					workflowToDataflowProcessors.get(block)).doEdit();
		}
	}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入依赖的package包/类
public SemanticAnnotationContextualView(FileManager fileManager,
		ComponentFactory factory, AbstractNamed selection) {
	super(fileManager, true);
	this.fileManager = fileManager;
	this.factory = factory;
	super.setAnnotated(selection);
	List<SemanticAnnotationProfile> profiles = new ArrayList<>();
	try {
		Profile componentProfile = getComponentProfile();
		if (componentProfile != null) {
			if (selection instanceof Workflow
					|| selection instanceof WorkflowBundle)
				profiles = componentProfile.getSemanticAnnotations();
			else if (selection instanceof InputWorkflowPort)
				profiles = componentProfile
						.getInputSemanticAnnotationProfiles();
			else if (selection instanceof OutputWorkflowPort)
				profiles = componentProfile
						.getOutputSemanticAnnotationProfiles();
			else if (selection instanceof Processor)
				profiles = componentProfile
						.getActivitySemanticAnnotationProfiles();
		}
	} catch (ComponentException e) {
		logger.error("failed to look up semantic annotations", e);
	}
	super.setSemanticAnnotationProfiles(profiles);
	super.initialise();
}