Java Workflow.getProcessors方法代码示例

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包/类
protected void assertHasProcessors(Workflow dataflow,
		String... expectedProcessors) {
	Set<String> expectedNames = new HashSet<String>();
	for (String expected : expectedProcessors) {
		expectedNames.add(expected);
	}
	Set<String> foundNames = new HashSet<String>();

	for (Processor proc : dataflow.getProcessors()) {
		String processorName = proc.getName();
		foundNames.add(processorName);
	}

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

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

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
@Override
public void visitWorkflow(Workflow bean) {
	Set<DataLink> dataLinks = bean.getDataLinks();
	Set<ControlLink> controlLinks = bean.getControlLinks();
	
	// ports are done in Ported
	
	NamedSet<Processor> processors = bean.getProcessors();
	URI workflowIdentifier = bean.getIdentifier();
	
	if (workflowIdentifier != null) {
		if (!workflowIdentifier.isAbsolute())
			listener.nonAbsoluteURI(bean, "workflowIdentifier", workflowIdentifier);
		else if (workflowIdentifier.getScheme().equals("file"))
			listener.nonAbsoluteURI(bean, "workflowIdentifier", workflowIdentifier);
	}
	
	if (checkComplete) {
		if (dataLinks == null)
			listener.nullField(bean, "dataLinks");
		if (controlLinks == null)
			listener.nullField(bean, "controlLinks");
		if (processors == null)
			listener.nullField(bean, "processors");
		if (workflowIdentifier == null)
			listener.nullField(bean, "workflowIdentifier");
	}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
@Test
public void readControlLinks() throws Exception {
	URL wfResource = getClass().getResource(SLEEPERS_T2FLOW);
	assertNotNull("Could not find workflow " + SLEEPERS_T2FLOW, wfResource);
	T2FlowParser parser = new T2FlowParser();
	parser.setStrict(true);
	WorkflowBundle bundle = parser.parseT2Flow(wfResource.openStream());
	Workflow mainWorkflow = bundle.getMainWorkflow();
	NamedSet<Processor> processors = mainWorkflow.getProcessors();
	assertEquals(4, mainWorkflow.getControlLinks().size());
	
	List<BlockingControlLink> blocking2 = scufl2Tools.controlLinksBlocking(processors.getByName("second_sleeper"));
	assertEquals(1, blocking2.size());
	assertEquals("first_sleeper", blocking2.get(0).getUntilFinished().getName());
	
	List<BlockingControlLink> waiting2 = scufl2Tools.controlLinksWaitingFor(processors.getByName("second_sleeper"));
	assertEquals(1, waiting2.size());
	assertEquals("third_sleeper", waiting2.get(0).getBlock().getName());
	
	
	List<BlockingControlLink> blocking3 = scufl2Tools.controlLinksBlocking(processors.getByName("third_sleeper"));
	assertEquals(2, blocking3.size());
	assertEquals("second_sleeper", blocking3.get(0).getUntilFinished().getName());
	assertEquals("second_sleeper_2", blocking3.get(1).getUntilFinished().getName());
	
	
	
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
private void findProcessors(WorkflowBundle ro, Workflow workflow,
		DefaultMutableTreeNode parent) {
	for (Processor processor : workflow.getProcessors()) {
		DefaultMutableTreeNode processorNode = new DefaultMutableTreeNode(
				processor.getName());
		parent.add(processorNode);
		Workflow wf = findNestedWorkflow(processor);
		if (wf != null) {
			findProcessors(ro, wf, processorNode);
		}
	}

}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
private void replaceAllMatchingActivities(URI activityType,
		ComponentActivityConfigurationBean cacb, String configString,
		boolean rename, Workflow d) throws IntermediateException {
	for (Processor p : d.getProcessors()) {
		Activity a = p.getActivity(sm.getSelectedProfile());
		if (a.getType().equals(activityType)
				&& getConfigString(a).equals(configString))
			replaceActivity(cacb, p, rename, d);
		else if (a.getType().equals(NESTED_WORKFLOW))
			replaceAllMatchingActivities(activityType, cacb, configString,
					rename,
					tools.nestedWorkflowForProcessor(p, a.getParent()));
	}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
void rememberSubworkflows(Processor p, CopiedProcessor copy) {
	for (Activity a : p.getActivity(sm.getSelectedProfile()))
		if (a instanceof NestedDataflow) {
			NestedDataflow da = (NestedDataflow) a;
			Workflow df = da.getNestedDataflow();
			if (!copy.requiredSubworkflows.containsKey(df.getIdentifier())) {
				copy.requiredSubworkflows.put(df.getIdentifier(),
						DataflowXMLSerializer.getInstance()
								.serializeDataflow(df));
				for (Processor sp : df.getProcessors())
					rememberSubworkflows(sp, copy);
			}
		}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
/**
 * Make an {@link Edit} that when performed merges the given source dataflow
 * into the destination dataflow.
 * <p>
 * Internally a copy is made of the source dataflow, to avoid modifying the
 * links and processors.
 *
 * @param sourceWorkflow
 *            Dataflow to merge from
 * @param prefix
 *            A prefix which will be inserted in front of the names for the
 *            merged workflow components.
 * @return An edit that can perform and undo the insertion of the components
 *         from the source dataflow.
 * @throws MergeException
 *             If the merge cannot be performed.
 */
public CompoundEdit getMergeEdit(Workflow sourceWorkflow, String prefix)
		throws MergeException {
	List<Edit<?>> compoundEdit = new ArrayList<>();

	Workflow workflow = copyWorkflow(sourceWorkflow);

	for (InputWorkflowPort input : workflow.getInputPorts()) {
		destinationWorkflow.getInputPorts().addWithUniqueName(input);
		destinationWorkflow.getInputPorts().remove(input);
		compoundEdit.add(new AddWorkflowInputPortEdit(destinationWorkflow, input));
	}
	for (OutputWorkflowPort output : workflow.getOutputPorts()) {
		destinationWorkflow.getOutputPorts().addWithUniqueName(output);
		destinationWorkflow.getOutputPorts().remove(output);
		compoundEdit.add(new AddWorkflowOutputPortEdit(destinationWorkflow, output));
	}
	for (Processor processor : workflow.getProcessors()) {
		processor.setName(prefix + processor.getName());
		compoundEdit.add(new AddProcessorEdit(destinationWorkflow, processor));
	}
	for (DataLink dataLink : workflow.getDataLinks()) {
		compoundEdit.add(new AddDataLinkEdit(destinationWorkflow, dataLink));
	}
	for (ControlLink controlLink : workflow.getControlLinks()) {
		compoundEdit.add(new AddChildEdit<Workflow>(destinationWorkflow, controlLink));
	}

	return new CompoundEdit(compoundEdit);

}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
protected Processor findProcessor(Workflow wf, String name) {
	for (Processor proc : wf.getProcessors()) {
		if (proc.getName().equals(name)) {
			return proc;
		}
	}
	throw new IllegalArgumentException("Unknown processor: " + name);
}
 

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 closingDataflow(ClosingDataflowEvent event,
		WorkflowBundle bundle) {
	Profile profile = bundle.getMainProfile();
	for (Workflow workflow : bundle.getWorkflows())
		for (Processor p : workflow.getProcessors()) {
			ProcessorBinding processorBinding = scufl2Tools
					.processorBindingForProcessor(p, profile);
			Activity activity = processorBinding.getBoundActivity();
			if (!closeDialog(activity))
				event.setAbortClose(true);
		}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
private void addProcessors(Workflow workflow, Dataflow dataflow)
		throws EditException, ActivityNotFoundException,
		ActivityConfigurationException, InvalidWorkflowException,
		DispatchLayerNotFoundException, DispatchLayerConfigurationException {
	for (Processor processor : workflow.getProcessors()) {
		org.apache.taverna.workflowmodel.Processor dataflowProcessor = edits
				.createProcessor(processor.getName());
		edits.getAddProcessorEdit(dataflow, dataflowProcessor).doEdit();
		// map the processor
		workflowToDataflowProcessors.put(processor, dataflowProcessor);
		dataflowToWorkflowProcessors.put(dataflowProcessor, processor);
		// add input ports
		for (InputProcessorPort inputProcessorPort : processor
				.getInputPorts()) {
			if (inputProcessorPort.getDatalinksTo().isEmpty())
				continue;
			ProcessorInputPort processorInputPort = edits
					.createProcessorInputPort(dataflowProcessor,
							inputProcessorPort.getName(),
							inputProcessorPort.getDepth());
			edits.getAddProcessorInputPortEdit(dataflowProcessor,
					processorInputPort).doEdit();
			inputPorts.put(inputProcessorPort, processorInputPort);
		}
		// add output ports
		for (OutputProcessorPort outputProcessorPort : processor
				.getOutputPorts()) {
			ProcessorOutputPort processorOutputPort = edits
					.createProcessorOutputPort(dataflowProcessor,
							outputProcessorPort.getName(),
							outputProcessorPort.getDepth(),
							outputProcessorPort.getGranularDepth());
			edits.getAddProcessorOutputPortEdit(dataflowProcessor,
					processorOutputPort).doEdit();
			outputPorts.put(outputProcessorPort, processorOutputPort);
		}

		// add dispatch stack
		addDispatchStack(processor, dataflowProcessor);

		addIterationStrategy(processor, dataflowProcessor);

		// add bound activities
		for (ProcessorBinding processorBinding : scufl2Tools
				.processorBindingsForProcessor(processor, profile))
			addActivity(processorBinding);
	}
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
public NestedWorkflowCreationDialog(Frame owner, Object o,
		Workflow dataflow, EditManager em, GraphViewComponent graphView) {
	super(owner, "Nested workflow creation", true, null);
	this.em = em;
	this.graphView = graphView;

	if (o instanceof Processor)
		includedProcessors.add((Processor) o);
	this.currentDataflow = dataflow;

	allProcessors = new ArrayList<>(dataflow.getProcessors());

	this.setLayout(new BorderLayout());
	JPanel buttonPanel = new JPanel();
	buttonPanel.setLayout(new FlowLayout());

	okButton = new DeselectingButton(new OKAction(this));
	buttonPanel.add(okButton);

	resetButton = new DeselectingButton(new ResetAction(this));
	buttonPanel.add(resetButton);

	JButton cancelButton = new DeselectingButton(new CancelAction(this));
	buttonPanel.add(cancelButton);

	JPanel innerPanel = new JPanel(new BorderLayout());
	JPanel processorChoice = createProcessorChoicePanel(dataflow);
	innerPanel.add(processorChoice, CENTER);

	JPanel namePanel = new JPanel(new FlowLayout());
	namePanel.add(new JLabel("Workflow name: "));
	nameField.setText("nested");
	namePanel.add(nameField);
	innerPanel.add(namePanel, SOUTH);

	this.add(innerPanel, CENTER);

	this.add(buttonPanel, SOUTH);
	this.pack();
	this.setSize(new Dimension(500, 800));
}
 

import org.apache.taverna.scufl2.api.core.Workflow; //导入方法依赖的package包/类
/**
 * Creates the tree model from a given workflow, for a given tree root.
 */
private void createTree(Workflow df, DefaultMutableTreeNode root) {
	// Create the four main node groups - inputs, outputs,
	// services, data links, control links and merges.
	DefaultMutableTreeNode inputs = new DefaultMutableTreeNode(INPUTS);
	DefaultMutableTreeNode outputs = new DefaultMutableTreeNode(OUTPUTS);
	DefaultMutableTreeNode services = new DefaultMutableTreeNode(PROCESSORS);
	DefaultMutableTreeNode datalinks = new DefaultMutableTreeNode(DATALINKS);
	DefaultMutableTreeNode controllinks = new DefaultMutableTreeNode(CONTROLLINKS);

	// Attach them to the root of the tree
	root.add(inputs);
	root.add(outputs);
	root.add(services);
	root.add(datalinks);
	root.add(controllinks);

	// Populate the workflow's inputs.
	for (InputWorkflowPort dataflowInput : df.getInputPorts())
		inputs.add(new DefaultMutableTreeNode(dataflowInput));

	// Populate the workflow's outputs.
	for (OutputWorkflowPort dataflowOutput : df.getOutputPorts())
		outputs.add(new DefaultMutableTreeNode(dataflowOutput));

	/*
	 * Populate the workflow's processors (which in turn can contain a
	 * nested workflow).
	 */
	NamedSet<Processor> processorsList = df.getProcessors();
	for (Processor processor : processorsList) {
		DefaultMutableTreeNode processorNode = new DefaultMutableTreeNode(
				processor);
		services.add(processorNode);

	    // A processor node can have children (input and output ports).
		for (InputProcessorPort inputPort : processor.getInputPorts())
			processorNode.add(new DefaultMutableTreeNode(inputPort));
		for (OutputProcessorPort outputPort : processor.getOutputPorts())
			processorNode.add(new DefaultMutableTreeNode(outputPort));
	}

	// Populate the workflow's data links.
	for (DataLink datalink: df.getDataLinks())
		datalinks.add(new DefaultMutableTreeNode(datalink));

	// Populate the workflow's control links.
	for (ControlLink controlLink : df.getControlLinks())
		controllinks.add(new DefaultMutableTreeNode(controlLink));
}