[jbpm-commits] JBoss JBPM SVN: r5393 - jbpm4/trunk/modules/bpmn/src/main/java/org/jbpm/bpmn/flownodes.

[do-not-reply at jboss.org]

Author: kukeltje
Date: 2009-07-30 12:50:20 -0400 (Thu, 30 Jul 2009)
New Revision: 5393

Modified:
   jbpm4/trunk/modules/bpmn/src/main/java/org/jbpm/bpmn/flownodes/BpmnActivity.java
Log:
Basic form of conditionExpressions working with juel. Including tests

Modified: jbpm4/trunk/modules/bpmn/src/main/java/org/jbpm/bpmn/flownodes/BpmnActivity.java
===================================================================
--- jbpm4/trunk/modules/bpmn/src/main/java/org/jbpm/bpmn/flownodes/BpmnActivity.java	2009-07-30 16:49:05 UTC (rev 5392)
+++ jbpm4/trunk/modules/bpmn/src/main/java/org/jbpm/bpmn/flownodes/BpmnActivity.java	2009-07-30 16:50:20 UTC (rev 5393)
@@ -25,7 +25,10 @@
 import java.util.List;
 
 import org.jbpm.api.Execution;
+import org.jbpm.api.JbpmException;
 import org.jbpm.api.activity.ActivityBehaviour;
+import org.jbpm.bpmn.parser.BindingsParser;
+import org.jbpm.internal.log.Log;
 import org.jbpm.pvm.internal.model.Activity;
 import org.jbpm.pvm.internal.model.Condition;
 import org.jbpm.pvm.internal.model.ExecutionImpl;
@@ -35,72 +38,108 @@
  * Basic activity for BPMN activities (tasks, gateways and event)
  * 
  * @author bernd.ruecker at camunda.com
+ * @author Ronald van Kuijk (kukeltje)
  */
 public abstract class BpmnActivity implements ActivityBehaviour {
 
-    private static final long serialVersionUID = 1L;
+  private static final Log log = Log.getLog(BindingsParser.class.getName());
+  
+  private static final long serialVersionUID = 1L;
 
-    public void leaveBpmnActivity(ExecutionImpl execution) {
-	// TODO: Move to AbstractTask? Different in Gateway...
-	// TODO: must be used!
-	proceedForked(execution);
+  private static final boolean FORK_ALLOWED = true;
+  private static final boolean FORK_DISALLOWED = !FORK_ALLOWED;
+  private static final boolean CONDITIONS_CHECKED = true;
+  private static final boolean CONDITIONS_IGNORED = !CONDITIONS_CHECKED;
+
+  protected void leaveBpmnActivity(ExecutionImpl execution) {
+
+    proceedForkedIfAllowed(execution, FORK_ALLOWED, CONDITIONS_CHECKED);
+
+  }
+
+  protected void leaveBpmnActivitySingle(ExecutionImpl execution) {
+
+    proceedForkedIfAllowed(execution, FORK_DISALLOWED, CONDITIONS_CHECKED);
+
+  }
+  
+  protected void leaveBpmnActivityAll(ExecutionImpl execution) {
+
+    proceedForkedIfAllowed(execution, FORK_ALLOWED, CONDITIONS_IGNORED);
+
+  }
+
+  /**
+   * In BPMN multiple outgoing sequence flows behave like a fork.
+   * 
+   * Code copied basically from jPDL fork.
+   */
+  private void proceedForkedIfAllowed(ExecutionImpl execution, boolean forkAllowed, boolean checkConditions) {
+    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) || (!checkConditions) || (condition.evaluate(execution)) ) {
+        forkingTransitions.add(transition);
+      }
     }
+    log.debug(forkingTransitions.size() + " out of "+ outgoingTransitions.size() + " selected for " + activity.getName());
+   
+    // if no outgoing transitions should be forked,
+    if (forkingTransitions.size() == 0) {
+      // end this execution
+      execution.end();
 
-    /**
-     * In BPMN multiple outgoing sequence flows behave like a fork.
-     * 
-     * Code copied basically from jPDL fork.
-     */
-    public void proceedForked(ExecutionImpl execution) {
-	Activity activity = execution.getActivity();
+      // if there is exactly 1 transition to be taken, just use the incoming
+      // execution
+    } else if (forkingTransitions.size() == 1) {
+      execution.take(forkingTransitions.get(0));
 
-	// 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 there are more transitions
+    } else {
+      if (forkAllowed) {
+        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();
+        }
 
-	// if no outgoing transitions should be forked,
-	if (forkingTransitions.size() == 0) {
-	    // end this execution
-	    execution.end();
+        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 there is exactly 1 transition to be taken, just use the
-	    // incoming execution
-	}
-	else if (forkingTransitions.size() == 1) {
-	    execution.take(forkingTransitions.get(0));
+          if (concurrentRoot.isEnded()) {
+            break;
+          }
+        }
+      } else {
+        throw new JbpmException("To many outgoing transition conditions evaluated to true for " + execution.getActivity());
+      }
+    }
 
-	    // 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();
-	    }
+  }
 
-	    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);
+  protected List<Transition> findTransitions(ExecutionImpl execution, Activity activity) {
 
-		if (concurrentRoot.isEnded()) {
-		    break;
-		}
-	    }
-	}
+    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);
+      }
     }
-}
+    return forkingTransitions;
+
+  }
+}
\ No newline at end of file