Java RouteNode.getNextNodes方法代码示例

import org.kuali.rice.kew.engine.node.RouteNode; //导入方法依赖的package包/类
private boolean isNodeNameInPath(String nodeName, RouteNode node, Set<String> inspected) throws Exception {
    boolean isInPath = !inspected.contains(node.getRouteNodeId()) && node.getRouteNodeName().equals(nodeName);
    inspected.add(node.getRouteNodeId());
    if (helper.isSubProcessNode(node)) {
        ProcessDefinitionBo subProcess = node.getDocumentType().getNamedProcess(node.getRouteNodeName());
        RouteNode subNode = subProcess.getInitialRouteNode();
        if (subNode != null) {
            isInPath = isInPath || isNodeNameInPath(nodeName, subNode, inspected);
        }
    }
    for (RouteNode nextNode : node.getNextNodes())
    {
        isInPath = isInPath || isNodeNameInPath(nodeName, nextNode, inspected);
    }
    return isInPath;
}
 

import org.kuali.rice.kew.engine.node.RouteNode; //导入方法依赖的package包/类
private static Integer getLevelForNode(RouteNode node, String nodeName, Integer currentLevel) {
    if (node == null) {
        throw new WorkflowRuntimeException("Could not locate node with name '"+nodeName+"'");
    }
    // TODO potential for infinite recursion here if their document type has loops in it.  Should this be a concern?
    // If their routing version is really "route level" then there should be no cycles.
    if (node.getRouteNodeName().equals(nodeName)) {
        return currentLevel;
    }
    List<RouteNode> nextNodes = node.getNextNodes();
    if (nextNodes.isEmpty()) {
        throw new WorkflowRuntimeException("Could not locate node with name '"+nodeName+"'");
    }
    if (nextNodes.size() > 1) {
        throw new WorkflowRuntimeException("Can only determine route level for document types with no splitting");
    }
    RouteNode nextNode = (RouteNode)nextNodes.get(0);
    return getLevelForNode(nextNode, nodeName, new Integer(currentLevel.intValue()+1));
}
 

import org.kuali.rice.kew.engine.node.RouteNode; //导入方法依赖的package包/类
private String determineFutureNodeName(RouteNode node, MovePoint movePoint, int currentStep, Set nodesProcessed) throws InvalidActionTakenException {
    if (nodesProcessed.contains(node.getRouteNodeId())) {
        throw new InvalidActionTakenException("Detected a cycle at node " + node.getRouteNodeName() + " when attempting to move document.");
    }
    nodesProcessed.add(node.getRouteNodeId());
    if (currentStep == movePoint.getStepsToMove()) {
        return node.getRouteNodeName();
    }
    List nextNodes = node.getNextNodes();
    if (nextNodes.size() == 0) {
        throw new InvalidActionTakenException("Could not proceed forward, there are no more nodes in the route.  Halted on step " + currentStep);
    }
    if (nextNodes.size() != 1) {
        throw new InvalidActionTakenException("Cannot move forward in a multi-branch path.  Located "+nextNodes.size()+" branches.  Halted on step " + currentStep);
    }
    return determineFutureNodeName((RouteNode)nextNodes.get(0), movePoint, currentStep+1, nodesProcessed);
}
 

import org.kuali.rice.kew.engine.node.RouteNode; //导入方法依赖的package包/类
/**
 * Returns a list of RouteNodes in a flat list which is equivalent to the route level concept of
 * Workflow <= version 2.0.  If the document type is not route level compatible, then this method will throw an error.
 */
public static List<RouteNode> getRouteLevelCompatibleNodeList(DocumentType documentType) {
    if (!isRouteLevelCompatible(documentType)) {
        throw new WorkflowRuntimeException("Attempting to invoke a 'route level' operation on a document which is not route level compatible.");
    }
    ProcessDefinitionBo primaryProcess = documentType.getPrimaryProcess();
    RouteNode routeNode = primaryProcess.getInitialRouteNode();
    List<RouteNode> nodes = new ArrayList<RouteNode>();
    int count = 0;
    int maxCount = 100;
    if (routeNode != null) {
        while (true) {
            nodes.add(routeNode);
            List<RouteNode> nextNodes = routeNode.getNextNodes();
            if (nextNodes.size() == 0) {
                break;
            }
            if (nextNodes.size() > 1) {
                throw new RuntimeException("Node has more than one next node!  It is not route level compatible!" + routeNode.getRouteNodeName());
            }
            if (count >= maxCount) {
                throw new RuntimeException("A runaway loop was detected when attempting to create route level compatible node graph.  documentType=" + documentType.getDocumentTypeId()+","+documentType.getName());
            }
            routeNode = nextNodes.iterator().next();
        }
    }
    return nodes;
}
 

import org.kuali.rice.kew.engine.node.RouteNode; //导入方法依赖的package包/类
protected RouteNode flattenSplitNode( RouteNode splitNode, Map<String,RouteNode> nodes ) {
	nodes.put( splitNode.getRouteNodeName(), splitNode );
	RouteNode joinNode = null;
	
	for ( RouteNode nextNode : splitNode.getNextNodes() ) {
		joinNode = flattenRouteNodes(nextNode, nodes);
	}
	
	if ( joinNode != null ) {
		nodes.put( joinNode.getRouteNodeName(), joinNode );
	}
	return joinNode;
}