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(a)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
Show replies by date