public Edit getMapProcessorPortsForActivityEdit()

in taverna-workflowmodel-impl/src/main/java/org/apache/taverna/workflowmodel/impl/EditsImpl.java [979:1112]
121 lines of code
30 McCabe index (conditional complexity)

	public Edit<Processor> getMapProcessorPortsForActivityEdit(
			final Processor processor) {
		return new EditSupport<Processor>() {
			@Override
			public Processor applyEdit() throws EditException {
				List<Edit<?>> edits = new ArrayList<>();
				Activity<?> a = processor.getActivityList().get(0);

				List<ProcessorInputPort> inputPortsForRemoval = determineInputPortsForRemoval(
						processor, a);
				List<ProcessorOutputPort> outputPortsForRemoval = determineOutputPortsForRemoval(
						processor, a);
				Map<ProcessorInputPort, ActivityInputPort> changedInputPorts = determineChangedInputPorts(
						processor, a);
				Map<ProcessorOutputPort, ActivityOutputPort> changedOutputPorts = determineChangedOutputPorts(
						processor, a);

				for (ProcessorInputPort ip : inputPortsForRemoval) {
					if (ip.getIncomingLink() != null)
						edits.add(getDisconnectDatalinkEdit(ip
								.getIncomingLink()));
					edits.add(getRemoveProcessorInputPortEdit(processor, ip));
					if (a.getInputPortMapping().containsKey(ip.getName()))
						edits.add(getRemoveActivityInputPortMappingEdit(a, ip
								.getName()));
				}
				
				for (ProcessorOutputPort op : outputPortsForRemoval) {
					if (!op.getOutgoingLinks().isEmpty())
						for (Datalink link : op.getOutgoingLinks())
							edits.add(getDisconnectDatalinkEdit(link));
					edits.add(getRemoveProcessorOutputPortEdit(processor, op));
					if (a.getOutputPortMapping().containsKey(op.getName()))
						edits.add(getRemoveActivityOutputPortMappingEdit(a, op
								.getName()));
				}

				for (ProcessorInputPort ip : changedInputPorts.keySet()) {
					Datalink incomingLink = ip.getIncomingLink();
					if (incomingLink != null)
						edits.add(getDisconnectDatalinkEdit(incomingLink));
					edits.add(getRemoveProcessorInputPortEdit(processor, ip));
					
					if (incomingLink != null) {
						ActivityInputPort aip = changedInputPorts.get(ip);
						ProcessorInputPort pip = createProcessorInputPort(processor,
								aip.getName(), aip.getDepth());
						edits.add(getAddProcessorInputPortEdit(processor, pip));
						edits.add(getConnectDatalinkEdit(new DatalinkImpl(
								incomingLink.getSource(), pip)));
					}
				}
				
				for (ProcessorOutputPort op : changedOutputPorts.keySet()) {
					Set<? extends Datalink> outgoingLinks = op.getOutgoingLinks();
					for (Datalink link : outgoingLinks)
						edits.add(getDisconnectDatalinkEdit(link));
					edits.add(getRemoveProcessorOutputPortEdit(processor, op));
					
					if (!outgoingLinks.isEmpty()) {
						ActivityOutputPort aop = changedOutputPorts.get(op);
						ProcessorOutputPort pop = createProcessorOutputPort(
								processor, aop.getName(), aop.getDepth(),
								aop.getGranularDepth());
						edits.add(getAddProcessorOutputPortEdit(processor,
								pop));
						for (Datalink link : outgoingLinks)
							edits.add(getConnectDatalinkEdit(createDatalink(
									pop, link.getSink())));
					}
				}

				new CompoundEdit(edits).doEdit();
				return processor;
			}

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

			private List<ProcessorInputPort> determineInputPortsForRemoval(Processor p,
					Activity<?> a) {
				List<ProcessorInputPort> result = new ArrayList<>();
				processorPorts: for (ProcessorInputPort pPort : p.getInputPorts()) {
					for (ActivityInputPort aPort : a.getInputPorts())
						if (aPort.getName().equals(pPort.getName()))
							continue processorPorts;
					result.add(pPort);
				}
				return result;
			}
			
			private List<ProcessorOutputPort> determineOutputPortsForRemoval(
					Processor p, Activity<?> a) {
				List<ProcessorOutputPort> result = new ArrayList<>();
				processorPorts: for (ProcessorOutputPort pPort : p.getOutputPorts()) {
					for (OutputPort aPort : a.getOutputPorts())
						if (aPort.getName().equals(pPort.getName()))
							continue processorPorts;
					result.add(pPort);
				}
				return result;
			}
			
			private Map<ProcessorInputPort, ActivityInputPort> determineChangedInputPorts(
					Processor p, Activity<?> a) {
				Map<ProcessorInputPort, ActivityInputPort> result = new HashMap<>();
				for (ProcessorInputPort pPort : p.getInputPorts())
					for (ActivityInputPort aPort : a.getInputPorts())
						if (aPort.getName().equals(pPort.getName())) {
							if (pPort.getDepth() != aPort.getDepth())
								result.put(pPort, aPort);
							break;
						}
				return result;
			}
			
			private Map<ProcessorOutputPort, ActivityOutputPort> determineChangedOutputPorts(
					Processor p, Activity<?> a) {
				Map<ProcessorOutputPort, ActivityOutputPort> result = new HashMap<>();
				for (ProcessorOutputPort pPort : p.getOutputPorts())
					for (OutputPort aPort : a.getOutputPorts())
						if (aPort.getName().equals(pPort.getName())) {
							if ((pPort.getDepth() != aPort.getDepth())
									|| (pPort.getGranularDepth() != aPort
											.getGranularDepth()))
								result.put(pPort, (ActivityOutputPort) aPort);
							break;
						}
				return result;
			}
		};
	}