ForkActivity批改

ForkActivity修改
Problems with nested Forks

源代码修改



package org.jbpm.jpdl.internal.activity;

import java.util.ArrayList;
import java.util.List;

import org.jbpm.api.Execution;
import org.jbpm.api.activity.ActivityExecution;
import org.jbpm.pvm.internal.model.Activity;
import org.jbpm.pvm.internal.model.Condition;
import org.jbpm.pvm.internal.model.ExecutionImpl;
import org.jbpm.pvm.internal.model.Transition;


public class ForkActivity extends JpdlActivity {

private static final long serialVersionUID = 1L;

public void execute(ActivityExecution execution) {
   execute((ExecutionImpl) execution);
}

public void execute(ExecutionImpl execution) {
   Activity activity = execution.getActivity();

   // evaluate the conditions and find the transitions that should be
   // forked
   List<Transition> forkingTransitions = new ArrayList<Transition>();
   List<Transition> outgoingTransitions = activity
     .getOutgoingTransitions();
   for (Transition transition : outgoingTransitions) {
    Condition condition = transition.getCondition();
    if ((condition == null) || (condition.evaluate(execution))) {
     forkingTransitions.add(transition);
    }
   }

   // if no outgoing transitions should be forked,
   if (forkingTransitions.size() == 0) {
    // end this execution
    execution.end();

    // if there is exactly 1 transition to be taken, just use the
    // incoming execution
   } else if (forkingTransitions.size() == 1) {
    execution.take(forkingTransitions.get(0));

    // if there are more transitions
   } else {
    ExecutionImpl concurrentRoot = null;
    if (Execution.STATE_ACTIVE_ROOT.equals(execution.getState())) {
     concurrentRoot = execution;
     execution.setState(Execution.STATE_INACTIVE_CONCURRENT_ROOT);
     execution.setActivity(null);
    } else if (Execution.STATE_ACTIVE_CONCURRENT.equals(execution
      .getState())) {
     concurrentRoot = execution.getParent();
     // 添加代码
     execution.setState(Execution.STATE_INACTIVE_CONCURRENT_ROOT);
     execution.setActivity(null);
     // 添加代码
    }

    // 添加代码
    if (Execution.STATE_INACTIVE_CONCURRENT_ROOT.equals(execution
      .getState())) {

     // 执行挂起
     execution.suspend();

    }
    // 添加代码

    for (Transition transition : forkingTransitions) {
     // launch a concurrent path of execution
     String childExecutionName = transition.getName();
     ExecutionImpl concurrentExecution = concurrentRoot
       .createExecution(childExecutionName);
     concurrentExecution.setActivity(activity);
     concurrentExecution.setState(Execution.STATE_ACTIVE_CONCURRENT);
     concurrentExecution.take(transition);

     if (concurrentRoot.isEnded()) {
      break;
     }
    }
   }
}
}