[jbpm-commits] JBoss JBPM SVN: r6085 - in jbpm3/branches/jbpm-3.2-soa/modules/core/src: main/java/org/jbpm/command and 12 other directories.
do-not-reply at jboss.org
do-not-reply at jboss.org
Fri Jan 15 22:29:46 EST 2010
Author: alex.guizar at jboss.com
Date: 2010-01-15 22:29:46 -0500 (Fri, 15 Jan 2010)
New Revision: 6085
Modified:
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/bytes/ByteArray.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/command/UnlockTokenCommand.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Action.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Event.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Transition.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Comment.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/RuntimeAction.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Token.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/instantiation/Delegation.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/def/ModuleDefinition.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/exe/ModuleInstance.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/Swimlane.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/TaskController.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/EqualsUtil.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/TokenCommandTest.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/db/GraphSessionDbTest.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/graph/node/ProcessStateDbTest.java
jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/taskmgmt/exe/EndTasksDbTest.java
Log:
JBPM-2489: deprecate EqualsUtil.equals and replace all uses with correct equals() and hashCode() implementations
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/bytes/ByteArray.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/bytes/ByteArray.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/bytes/ByteArray.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -28,28 +28,31 @@
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+
+import org.jbpm.util.ArrayUtil;
import org.jbpm.util.StringUtil;
/**
- * is a persistable array of bytes. While there is no generic way of storing blobs
- * that is supported by many databases, all databases are able to handle small chunks
- * of bytes properly. It is the responsibility of this class to chop the large byte
- * array into small chunks of 1K (and combine the chunks again in the reverse way).
- * Hibernate will persist the list of byte-chunks in the database.
+ * is a persistable array of bytes. While there is no generic way of storing
+ * blobs that is supported by many databases, all databases are able to handle
+ * small chunks of bytes properly. It is the responsibility of this class to
+ * chop the large byte array into small chunks of 1K (and combine the chunks
+ * again in the reverse way). Hibernate will persist the list of byte-chunks in
+ * the database.
*
- * ByteArray is used in process variableInstances and in the file module (that stores the
- * non-parsed process archive files).
+ * ByteArray is used in process variableInstances and in the file module (that
+ * stores the non-parsed process archive files).
*/
public class ByteArray implements Serializable {
-
+
private static final long serialVersionUID = 1L;
-
+
long id;
protected String name;
protected List byteBlocks;
-
+
private static final Log log = LogFactory.getLog(ByteArray.class);
-
+
public ByteArray() {
}
@@ -63,15 +66,15 @@
}
void logBlocks(String msg) {
- for(int blockIndex=0; blockIndex<byteBlocks.size(); blockIndex++) {
+ for (int blockIndex = 0; blockIndex < byteBlocks.size(); blockIndex++) {
byte[] block = (byte[]) byteBlocks.get(blockIndex);
- log.debug(msg+"["+block.length+"] "+StringUtil.toHexString(block));
+ log.debug(msg + "[" + block.length + "] " + StringUtil.toHexString(block));
}
}
-
+
public ByteArray(ByteArray other) {
List otherByteBlocks = other.getByteBlocks();
- if (otherByteBlocks!=null) {
+ if (otherByteBlocks != null) {
this.byteBlocks = new ArrayList(otherByteBlocks);
}
this.name = other.name;
@@ -86,15 +89,34 @@
}
public boolean equals(Object o) {
- if (o==null) return false;
- if (! (o instanceof ByteArray)) return false;
+ if (o == this) return true;
+ if (!(o instanceof ByteArray)) return false;
+
ByteArray other = (ByteArray) o;
- return Arrays.equals(ByteBlockChopper.glueChopsBackTogether(byteBlocks), ByteBlockChopper.glueChopsBackTogether(other.byteBlocks));
+ if (id != 0 && id == other.getId()) return true;
+
+ List byteBlocks = this.byteBlocks;
+ List otherByteBlocks = other.getByteBlocks();
+ int n = byteBlocks.size();
+ if (n != otherByteBlocks.size()) return false;
+
+ for (int i = 0; i < n; i++) {
+ byte[] byteBlock = (byte[]) byteBlocks.get(i);
+ byte[] otherByteBlock = (byte[]) otherByteBlocks.get(i);
+ if (!Arrays.equals(byteBlock, otherByteBlock)) return false;
+ }
+ return true;
}
public int hashCode() {
- if (byteBlocks==null) return 0;
- return byteBlocks.hashCode();
+ if (byteBlocks == null) return 0;
+
+ int result = 1;
+ for (int i = 0, n = byteBlocks.size(); i < n; i++) {
+ byte[] byteBlock = (byte[]) byteBlocks.get(i);
+ result = 31 * result + ArrayUtil.hashCode(byteBlock);
+ }
+ return result;
}
public List getByteBlocks() {
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/command/UnlockTokenCommand.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/command/UnlockTokenCommand.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/command/UnlockTokenCommand.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -26,7 +26,7 @@
}
else {
// requires newer jbpm version, see https://jira.jboss.org/jira/browse/JBPM-1888
- token.foreUnlock();
+ token.forceUnlock();
}
return token;
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Action.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Action.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Action.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -32,8 +32,6 @@
import org.jbpm.jpdl.el.impl.JbpmExpressionEvaluator;
import org.jbpm.jpdl.xml.JpdlXmlReader;
import org.jbpm.jpdl.xml.Parsable;
-import org.jbpm.util.ClassUtil;
-import org.jbpm.util.EqualsUtil;
public class Action implements ActionHandler, Parsable, Serializable {
@@ -58,46 +56,43 @@
}
public String toString() {
- String toString = null;
- if (actionExpression != null) {
- toString = "Action(" + actionExpression + ')';
+ StringBuffer result = new StringBuffer("Action(");
+ if (name != null) {
+ result.append(name);
}
- else {
- String className = ClassUtil.getSimpleName(getClass());
- if (name != null) {
- toString = className + '(' + name + ')';
- }
- else {
- toString = className + '@' + Integer.toHexString(hashCode());
- }
+ else if (actionDelegation != null) {
+ result.append(actionDelegation);
}
- return toString;
+ else if (actionExpression != null) {
+ result.append(actionExpression);
+ }
+ else if (referencedAction != null) {
+ result.append(referencedAction.getName());
+ }
+ return result.append(')').toString();
}
public void read(Element actionElement, JpdlXmlReader jpdlReader) {
String expression = actionElement.attributeValue("expression");
if (expression != null) {
actionExpression = expression;
-
}
else if (actionElement.attribute("ref-name") != null) {
jpdlReader.addUnresolvedActionReference(actionElement, this);
-
}
else if (actionElement.attribute("class") != null) {
actionDelegation = new Delegation();
actionDelegation.read(actionElement, jpdlReader);
-
}
else {
jpdlReader.addWarning("action does not have class nor ref-name attribute "
- + actionElement.asXML());
+ + actionElement.asXML());
}
String acceptPropagatedEvents = actionElement.attributeValue("accept-propagated-events");
if ("false".equalsIgnoreCase(acceptPropagatedEvents)
- || "no".equalsIgnoreCase(acceptPropagatedEvents)
- || "off".equalsIgnoreCase(acceptPropagatedEvents)) {
+ || "no".equalsIgnoreCase(acceptPropagatedEvents)
+ || "off".equalsIgnoreCase(acceptPropagatedEvents)) {
isPropagationAllowed = false;
}
@@ -118,19 +113,19 @@
}
public void execute(ExecutionContext executionContext) throws Exception {
- ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader();
+ ClassLoader surroundingClassLoader = Thread.currentThread()
+ .getContextClassLoader();
try {
- // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448)
- Thread.currentThread().setContextClassLoader(
- JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition()));
+ // set context class loader correctly for delegation class
+ // (https://jira.jboss.org/jira/browse/JBPM-1448)
+ ClassLoader classLoader = JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition());
+ Thread.currentThread().setContextClassLoader(classLoader);
if (referencedAction != null) {
referencedAction.execute(executionContext);
-
}
else if (actionExpression != null) {
JbpmExpressionEvaluator.evaluate(actionExpression, executionContext);
-
}
else if (actionDelegation != null) {
ActionHandler actionHandler = (ActionHandler) actionDelegation.getInstance();
@@ -147,8 +142,9 @@
if (processDefinition != null) {
// update the process definition action map
Map actionMap = processDefinition.getActions();
- // the != string comparison is to avoid null pointer checks. it is no problem if the body is executed a few times too much :-)
- if ((this.name != name) && (actionMap != null)) {
+ // the != string comparison is to avoid null pointer checks.
+ // no problem if the body is executed a few times too much :-)
+ if (this.name != name && actionMap != null) {
actionMap.remove(this.name);
actionMap.put(name, this);
}
@@ -159,12 +155,48 @@
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof Action)) return false;
+
+ Action other = (Action) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ if (name != null) {
+ // named actions are unique at the process definition level
+ return name.equals(other.getName())
+ && processDefinition.equals(other.getProcessDefinition());
+ }
+ return (actionDelegation != null ? actionDelegation.equals(other.getActionDelegation())
+ : actionExpression != null ? actionExpression.equals(other.getActionExpression())
+ : referencedAction != null ? referencedAction.equals(other.getActionExpression())
+ : false)
+ && event.equals(other.getEvent());
}
+ public int hashCode() {
+ int result = 1397928647;
+ if (name != null) {
+ // named actions are unique at the process definition level
+ result += name.hashCode();
+ result = 1290535769 * result + processDefinition.hashCode();
+ }
+ else {
+ if (actionDelegation != null) {
+ result += actionDelegation.hashCode();
+ }
+ else if (actionExpression != null) {
+ result += actionExpression.hashCode();
+ }
+ else if (referencedAction != null) {
+ result += referencedAction.hashCode();
+ }
+ result = 1290535769 * result + event.hashCode();
+ }
+ return result;
+ }
+
// getters and setters //////////////////////////////////////////////////////
public boolean acceptsPropagatedEvents() {
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Event.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Event.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Event.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -25,10 +25,8 @@
import java.util.ArrayList;
import java.util.List;
-import org.jbpm.util.EqualsUtil;
+public class Event implements Serializable {
-public class Event implements Serializable {
-
private static final long serialVersionUID = 1L;
public static final String EVENTTYPE_TRANSITION = "transition";
@@ -49,16 +47,16 @@
public static final String EVENTTYPE_TIMER_CREATE = "timer-create";
public static final String EVENTTYPE_TIMER = "timer";
- long id = 0;
- protected String eventType = null;
- protected GraphElement graphElement = null;
- protected List actions = null;
-
+ long id;
+ protected String eventType;
+ protected GraphElement graphElement;
+ protected List actions;
+
// constructors /////////////////////////////////////////////////////////////
public Event() {
}
-
+
public Event(String eventType) {
this.eventType = eventType;
}
@@ -72,6 +70,7 @@
/**
* is the list of actions associated to this event.
+ *
* @return an empty list if no actions are associated.
*/
public List getActions() {
@@ -79,25 +78,26 @@
}
public boolean hasActions() {
- return ( (actions!=null)
- && (actions.size()>0) );
+ return actions != null && actions.size() > 0;
}
public Action addAction(Action action) {
- if (action==null) throw new IllegalArgumentException("can't add a null action to an event");
- if (actions==null) actions = new ArrayList();
+ if (action == null) {
+ throw new IllegalArgumentException("action is null");
+ }
+ if (actions == null) actions = new ArrayList();
actions.add(action);
action.event = this;
return action;
}
public void removeAction(Action action) {
- if (action==null) throw new IllegalArgumentException("can't remove a null action from an event");
- if (actions!=null) {
- if (actions.remove(action)) {
- action.event=null;
- }
+ if (action == null) {
+ throw new IllegalArgumentException("action is null");
}
+ if (actions != null && actions.remove(action)) {
+ action.event = null;
+ }
}
public String toString() {
@@ -105,23 +105,35 @@
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof Event)) return false;
+
+ Event other = (Event) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return eventType.equals(other.getEventType())
+ && graphElement.equals(other.getGraphElement());
}
+ public int hashCode() {
+ int result = 560044783 + eventType.hashCode();
+ result = 279308149 * result + graphElement.hashCode();
+ return result;
+ }
+
// getters and setters //////////////////////////////////////////////////////
public String getEventType() {
return eventType;
}
+
public GraphElement getGraphElement() {
return graphElement;
}
+
public long getId() {
return id;
}
-
- // private static final Log log = LogFactory.getLog(Event.class);
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/GraphElement.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -70,9 +70,10 @@
// events ///////////////////////////////////////////////////////////////////
/**
- * indicative set of event types supported by this graph element. this is currently only used
- * by the process designer to know which event types to show on a given graph element. in
- * process definitions and at runtime, there are no constraints on the event-types.
+ * indicative set of event types supported by this graph element. this is
+ * currently only used by the process designer to know which event types to
+ * show on a given graph element. in process definitions and at runtime, there
+ * are no constraints on the event-types.
*/
public abstract String[] getSupportedEventTypes();
@@ -97,10 +98,10 @@
public Event addEvent(Event event) {
if (event == null) {
- throw new IllegalArgumentException("can't add null event to graph element");
+ throw new IllegalArgumentException("event is null");
}
if (event.getEventType() == null) {
- throw new IllegalArgumentException("can't add an event without type to graph element");
+ throw new IllegalArgumentException("event type is null");
}
if (events == null) {
events = new HashMap();
@@ -113,11 +114,10 @@
public Event removeEvent(Event event) {
Event removedEvent = null;
if (event == null) {
- throw new IllegalArgumentException("can't remove null event from graph element");
+ throw new IllegalArgumentException("event is null");
}
if (event.getEventType() == null) {
- throw new IllegalArgumentException(
- "can't remove an event without type from graph element");
+ throw new IllegalArgumentException("event type is null");
}
if (events != null) {
removedEvent = (Event) events.remove(event.getEventType());
@@ -139,7 +139,7 @@
public ExceptionHandler addExceptionHandler(ExceptionHandler exceptionHandler) {
if (exceptionHandler == null) {
- throw new IllegalArgumentException("can't add null exceptionHandler to graph element");
+ throw new IllegalArgumentException("exception handler is null");
}
if (exceptionHandlers == null) {
exceptionHandlers = new ArrayList();
@@ -151,8 +151,7 @@
public void removeExceptionHandler(ExceptionHandler exceptionHandler) {
if (exceptionHandler == null) {
- throw new IllegalArgumentException(
- "can't remove null exceptionHandler from graph element");
+ throw new IllegalArgumentException("exception handler is null");
}
if (exceptionHandlers != null && exceptionHandlers.remove(exceptionHandler)) {
exceptionHandler.graphElement = null;
@@ -161,20 +160,21 @@
public void reorderExceptionHandler(int oldIndex, int newIndex) {
if (exceptionHandlers != null && Math.min(oldIndex, newIndex) >= 0
- && Math.max(oldIndex, newIndex) < exceptionHandlers.size()) {
+ && Math.max(oldIndex, newIndex) < exceptionHandlers.size()) {
Object o = exceptionHandlers.remove(oldIndex);
exceptionHandlers.add(newIndex, o);
}
else {
- throw new IndexOutOfBoundsException("couldn't reorder element from index '" + oldIndex
- + "' to index '" + newIndex + "' in " + exceptionHandlers);
+ throw new IndexOutOfBoundsException("could not move element from "
+ + oldIndex + " to " + newIndex);
}
}
// event handling ///////////////////////////////////////////////////////////
public void fireEvent(String eventType, ExecutionContext executionContext) {
- log.debug("event '" + eventType + "' on " + this + " for " + executionContext.getToken());
+ log.debug("event '" + eventType + "' on " + this + " for "
+ + executionContext.getToken());
try {
executionContext.setEventSource(this);
@@ -194,8 +194,10 @@
}
}
- public void fireAndPropagateEvent(String eventType, ExecutionContext executionContext) {
- // calculate if the event was fired on this element or if it was a propagated event
+ public void fireAndPropagateEvent(String eventType,
+ ExecutionContext executionContext) {
+ // check whether the event was fired on this element
+ // or propagated from another element
boolean isPropagated = !equals(executionContext.getEventSource());
// execute static actions
@@ -221,7 +223,8 @@
}
}
- void executeActions(List actions, ExecutionContext executionContext, boolean isPropagated) {
+ void executeActions(List actions, ExecutionContext executionContext,
+ boolean isPropagated) {
if (actions == null) return;
for (Iterator iter = actions.iterator(); iter.hasNext();) {
@@ -229,7 +232,8 @@
if (!action.acceptsPropagatedEvents() && isPropagated) continue;
if (action.isAsync()) {
- ExecuteActionJob job = createAsyncActionExecutionJob(executionContext.getToken(), action);
+ ExecuteActionJob job = createAsyncActionExecutionJob(
+ executionContext.getToken(), action);
MessageService messageService = (MessageService) Services.getCurrentService(Services.SERVICENAME_MESSAGE);
messageService.send(job);
}
@@ -239,7 +243,8 @@
}
}
- protected ExecuteActionJob createAsyncActionExecutionJob(Token token, Action action) {
+ protected ExecuteActionJob createAsyncActionExecutionJob(Token token,
+ Action action) {
ExecuteActionJob job = new ExecuteActionJob(token);
job.setAction(action);
job.setDueDate(new Date());
@@ -258,7 +263,8 @@
// the token needs to be locked. if this is an action
// being executed as the node behaviour or if the token
// is already locked, the token doesn't need to be locked.
- boolean actionMustBeLocked = executionContext.getEvent() != null && !token.isLocked();
+ boolean actionMustBeLocked = executionContext.getEvent() != null
+ && !token.isLocked();
try {
// update the execution context
@@ -285,8 +291,8 @@
}
}
catch (Exception exception) {
- // NOTE that Errors are not caught because that might halt the JVM and mask the original
- // Error
+ // NOTE that Errors are not caught because that might halt the JVM
+ // and mask the original Error
log.error("action threw exception: " + exception.getMessage(), exception);
// log the action exception
@@ -301,17 +307,21 @@
}
}
- List getRuntimeActionsForEvent(ExecutionContext executionContext, String eventType) {
+ List getRuntimeActionsForEvent(ExecutionContext executionContext,
+ String eventType) {
List runtimeActionsForEvent = null;
- List runtimeActions = executionContext.getProcessInstance().getRuntimeActions();
+ List runtimeActions = executionContext.getProcessInstance()
+ .getRuntimeActions();
if (runtimeActions != null) {
for (Iterator iter = runtimeActions.iterator(); iter.hasNext();) {
RuntimeAction runtimeAction = (RuntimeAction) iter.next();
- // if the runtime-action action is registered on this element and this eventType
+ // if the runtime action is registered on this element and eventType
if (equals(runtimeAction.getGraphElement())
- && eventType.equals(runtimeAction.getEventType())) {
+ && eventType.equals(runtimeAction.getEventType())) {
// ... add its action to the list of runtime actions
- if (runtimeActionsForEvent == null) runtimeActionsForEvent = new ArrayList();
+ if (runtimeActionsForEvent == null) {
+ runtimeActionsForEvent = new ArrayList();
+ }
runtimeActionsForEvent.add(runtimeAction.getAction());
}
}
@@ -320,14 +330,15 @@
}
/**
- * throws an ActionException if no applicable exception handler is found. An ExceptionHandler
- * is searched for in this graph element and then recursively up the parent hierarchy. If an
- * exception handler is found, it is applied. If the exception handler does not throw an
- * exception, the exception is considered handled. Otherwise the search for an applicable
- * exception handler continues where it left of with the newly thrown exception.
+ * throws an ActionException if no applicable exception handler is found. An
+ * ExceptionHandler is searched for in this graph element and then recursively
+ * up the parent hierarchy. If an exception handler is found, it is applied.
+ * If the exception handler does not throw an exception, the exception is
+ * considered handled. Otherwise the search for an applicable exception
+ * handler continues where it left of with the newly thrown exception.
*/
- public void raiseException(Throwable exception, ExecutionContext executionContext)
- throws DelegationException {
+ public void raiseException(Throwable exception,
+ ExecutionContext executionContext) throws DelegationException {
if (isAbleToHandleExceptions(executionContext)) {
try {
ExceptionHandler exceptionHandler = findExceptionHandler(exception);
@@ -355,30 +366,31 @@
// rollback the actions
// rollbackActions(executionContext);
- // if there is no parent we need to throw a delegation exception to the client
+ // if there is no parent, throw a delegation exception to the client
throw exception instanceof JbpmException ? (JbpmException) exception
: new DelegationException(exception, executionContext);
}
/**
- * Tells whether the given context is valid for exception handling by checking for:
+ * Tells whether the given context can handle exception by checking for:
* <ul>
* <li>the absence of a previous exception</li>
* <li>an active transaction, or no transaction at all</li>
* </ul>
*/
- private static boolean isAbleToHandleExceptions(ExecutionContext executionContext) {
+ private static boolean isAbleToHandleExceptions(
+ ExecutionContext executionContext) {
/*
- * if an exception is already set, we are already handling an exception; in this case don't
- * give the exception to the handlers but throw it to the client see
- * https://jira.jboss.org/jira/browse/JBPM-1887
+ * if an exception is already set, we are already handling an exception; in
+ * this case don't give the exception to the handlers but throw it to the
+ * client see https://jira.jboss.org/jira/browse/JBPM-1887
*/
if (executionContext.getException() != null) return false;
/*
- * check whether the transaction is still active before scanning the exception handlers.
- * that way we can load the exception handlers lazily see
- * https://jira.jboss.org/jira/browse/JBPM-1775
+ * check whether the transaction is still active before scanning the
+ * exception handlers. that way we can load the exception handlers lazily
+ * see https://jira.jboss.org/jira/browse/JBPM-1775
*/
JbpmContext jbpmContext = executionContext.getJbpmContext();
if (jbpmContext != null) {
@@ -386,7 +398,7 @@
if (service instanceof DbPersistenceService) {
DbPersistenceService persistenceService = (DbPersistenceService) service;
return persistenceService.isTransactionActive()
- || persistenceService.getTransaction() == null;
+ || persistenceService.getTransaction() == null;
}
}
@@ -448,16 +460,16 @@
if (!getClass().isInstance(o)) return false;
GraphElement other = (GraphElement) o;
- if (id != 0) return id == other.getId();
+ if (id != 0 && id == other.getId()) return true;
GraphElement parent = getParent();
- return (name != null ? name.equals(other.getName()) : other.getName() == null)
- && (parent != null ? parent.equals(other.getParent()) : other.getParent() == null);
+ return (name != null ? name.equals(other.getName())
+ : other.getName() == null)
+ && (parent != null ? parent.equals(other.getParent())
+ : other.getParent() == null);
}
public int hashCode() {
- if (id != 0) return (int) (id ^ (id >>> 32));
-
int result = 580399073 + (name != null ? name.hashCode() : 0);
GraphElement parent = getParent();
result = 345105097 * result + (parent != null ? parent.hashCode() : 0);
@@ -466,7 +478,8 @@
public String toString() {
return ClassUtil.getSimpleName(getClass())
- + (name != null ? '(' + name + ')' : '@' + Integer.toHexString(hashCode()));
+ + (name != null ? '(' + name + ')'
+ : '@' + Integer.toHexString(hashCode()));
}
// getters and setters //////////////////////////////////////////////////////
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/ProcessDefinition.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -65,13 +65,16 @@
// event types //////////////////////////////////////////////////////////////
- public static final String[] supportedEventTypes = new String[] {
- Event.EVENTTYPE_PROCESS_START, Event.EVENTTYPE_PROCESS_END, Event.EVENTTYPE_NODE_ENTER,
- Event.EVENTTYPE_NODE_LEAVE, Event.EVENTTYPE_TASK_CREATE, Event.EVENTTYPE_TASK_ASSIGN,
- Event.EVENTTYPE_TASK_START, Event.EVENTTYPE_TASK_END, Event.EVENTTYPE_TRANSITION,
- Event.EVENTTYPE_BEFORE_SIGNAL, Event.EVENTTYPE_AFTER_SIGNAL,
- Event.EVENTTYPE_SUPERSTATE_ENTER, Event.EVENTTYPE_SUPERSTATE_LEAVE,
- Event.EVENTTYPE_SUBPROCESS_CREATED, Event.EVENTTYPE_SUBPROCESS_END, Event.EVENTTYPE_TIMER };
+ public static final String[] supportedEventTypes = {
+ Event.EVENTTYPE_PROCESS_START, Event.EVENTTYPE_PROCESS_END,
+ Event.EVENTTYPE_NODE_ENTER, Event.EVENTTYPE_NODE_LEAVE,
+ Event.EVENTTYPE_TASK_CREATE, Event.EVENTTYPE_TASK_ASSIGN,
+ Event.EVENTTYPE_TASK_START, Event.EVENTTYPE_TASK_END,
+ Event.EVENTTYPE_TRANSITION, Event.EVENTTYPE_BEFORE_SIGNAL,
+ Event.EVENTTYPE_AFTER_SIGNAL, Event.EVENTTYPE_SUPERSTATE_ENTER,
+ Event.EVENTTYPE_SUPERSTATE_LEAVE, Event.EVENTTYPE_SUBPROCESS_CREATED,
+ Event.EVENTTYPE_SUBPROCESS_END, Event.EVENTTYPE_TIMER
+ };
public String[] getSupportedEventTypes() {
return supportedEventTypes;
@@ -86,20 +89,20 @@
public static ProcessDefinition createNewProcessDefinition() {
ProcessDefinition processDefinition = new ProcessDefinition();
- // now add all the default modules that are configured in the file jbpm.default.modules
+ // add all default modules from file jbpm.default.modules
String resource = JbpmConfiguration.Configs.getString("resource.default.modules");
Properties defaultModulesProperties = ClassLoaderUtil.getProperties(resource);
for (Iterator iter = defaultModulesProperties.keySet().iterator(); iter.hasNext();) {
String moduleClassName = (String) iter.next();
try {
- ModuleDefinition moduleDefinition = (ModuleDefinition) ClassLoaderUtil.classForName(moduleClassName)
+ ModuleDefinition moduleDefinition = (ModuleDefinition) ClassLoaderUtil.classForName(
+ moduleClassName)
.newInstance();
processDefinition.addDefinition(moduleDefinition);
-
}
catch (Exception e) {
- throw new JbpmException(
- "couldn't instantiate default module '" + moduleClassName + "'", e);
+ throw new JbpmException("could not instantiate module '"
+ + moduleClassName + '\'', e);
}
}
return processDefinition;
@@ -141,15 +144,16 @@
if (!(o instanceof ProcessDefinition)) return false;
ProcessDefinition other = (ProcessDefinition) o;
- return id != 0 ? id == other.getId() : (name != null ? name.equals(other.getName())
- : other.getName() == null)
- && version == other.getVersion();
+ if (id != 0 && id == other.getId()) return true;
+
+ return name != null && name.equals(other.getName())
+ && version == other.getVersion();
}
public int hashCode() {
- if (id != 0) return (int) (id ^ (id >>> 32));
+ if (name == null) return super.hashCode();
- int result = 224001527 + (name != null ? name.hashCode() : 0);
+ int result = 224001527 + name.hashCode();
result = 1568661329 * result + version;
return result;
}
@@ -177,7 +181,8 @@
if (resourceURL == null) {
throw new JpdlException("resource not found: " + xmlResource);
}
- JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(resourceURL.toString()));
+ JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(
+ resourceURL.toString()));
return jpdlReader.readProcessDefinition();
}
@@ -206,8 +211,8 @@
*
* @throws org.jbpm.jpdl.JpdlException if parsing reported an error.
*/
- public static ProcessDefinition parseParZipInputStream(ZipInputStream zipInputStream)
- throws IOException {
+ public static ProcessDefinition parseParZipInputStream(
+ ZipInputStream zipInputStream) throws IOException {
return new ProcessArchive(zipInputStream).parseProcessDefinition();
}
@@ -216,8 +221,10 @@
*
* @throws org.jbpm.jpdl.JpdlException if parsing reported an error.
*/
- public static ProcessDefinition parseParResource(String parResource) throws IOException {
- return parseParZipInputStream(new ZipInputStream(ClassLoaderUtil.getStream(parResource)));
+ public static ProcessDefinition parseParResource(String parResource)
+ throws IOException {
+ return parseParZipInputStream(new ZipInputStream(
+ ClassLoaderUtil.getStream(parResource)));
}
// nodes ////////////////////////////////////////////////////////////////////
@@ -255,8 +262,9 @@
// javadoc description in NodeCollection
public Node addNode(Node node) {
- if (node == null)
- throw new IllegalArgumentException("can't add a null node to a processdefinition");
+ if (node == null) {
+ throw new IllegalArgumentException("node is null");
+ }
if (nodes == null) nodes = new ArrayList();
nodes.add(node);
node.processDefinition = this;
@@ -271,8 +279,9 @@
// javadoc description in NodeCollection
public Node removeNode(Node node) {
Node removedNode = null;
- if (node == null)
- throw new IllegalArgumentException("can't remove a null node from a process definition");
+ if (node == null) {
+ throw new IllegalArgumentException("node is null");
+ }
if (nodes != null) {
if (nodes.remove(node)) {
removedNode = node;
@@ -290,13 +299,13 @@
// javadoc description in NodeCollection
public void reorderNode(int oldIndex, int newIndex) {
if (nodes != null && Math.min(oldIndex, newIndex) >= 0
- && Math.max(oldIndex, newIndex) < nodes.size()) {
+ && Math.max(oldIndex, newIndex) < nodes.size()) {
Object node = nodes.remove(oldIndex);
nodes.add(newIndex, node);
}
else {
- throw new IndexOutOfBoundsException("couldn't reorder element from index " + oldIndex
- + " to index " + newIndex);
+ throw new IndexOutOfBoundsException("could not move node from "
+ + oldIndex + " to " + newIndex);
}
}
@@ -311,7 +320,7 @@
}
public static String generateNodeName(List nodes) {
- String name = null;
+ String name;
if (nodes == null) {
name = "1";
}
@@ -327,18 +336,18 @@
static boolean containsName(List nodes, String name) {
for (Iterator iter = nodes.iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
- if (name.equals(node.getName())) {
- return true;
- }
+ if (name.equals(node.getName())) return true;
}
return false;
}
- public static Node findNode(NodeCollection nodeCollection, String hierarchicalName) {
+ public static Node findNode(NodeCollection nodeCollection,
+ String hierarchicalName) {
Node node = null;
if (hierarchicalName != null && hierarchicalName.trim().length() > 0) {
- if (hierarchicalName.startsWith("/") && nodeCollection instanceof SuperState) {
+ if (hierarchicalName.charAt(0) == '/'
+ && nodeCollection instanceof SuperState) {
nodeCollection = ((SuperState) nodeCollection).getProcessDefinition();
}
@@ -348,7 +357,7 @@
if ("..".equals(namePart)) {
if (nodeCollection instanceof ProcessDefinition) {
throw new JbpmException("could not find node '" + hierarchicalName
- + "' because of a '..' on the process definition.");
+ + "' because of a '..' on the process definition.");
}
nodeCollection = (NodeCollection) ((GraphElement) nodeCollection).getParent();
}
@@ -380,15 +389,19 @@
// actions //////////////////////////////////////////////////////////////////
/**
- * creates a bidirectional relation between this process definition and the given action.
+ * creates a bidirectional relation between this process definition and the
+ * given action.
*
- * @throws IllegalArgumentException if action is null or if action.getName() is null.
+ * @throws IllegalArgumentException if action is null or if action.getName()
+ * is null.
*/
public Action addAction(Action action) {
- if (action == null)
- throw new IllegalArgumentException("can't add a null action to an process definition");
- if (action.getName() == null)
- throw new IllegalArgumentException("can't add an unnamed action to an process definition");
+ if (action == null) {
+ throw new IllegalArgumentException("action is null");
+ }
+ if (action.getName() == null) {
+ throw new IllegalArgumentException("action is unnamed");
+ }
if (actions == null) actions = new HashMap();
actions.put(action.getName(), action);
action.processDefinition = this;
@@ -396,20 +409,20 @@
}
/**
- * removes the bidirectional relation between this process definition and the given action.
+ * removes the bidirectional relation between this process definition and the
+ * given action.
*
- * @throws IllegalArgumentException if action is null or if the action was not present in the
- * actions of this process definition.
+ * @throws IllegalArgumentException if action is null or if the action was not
+ * present in the actions of this process definition.
*/
public void removeAction(Action action) {
if (action == null) {
- throw new IllegalArgumentException(
- "can't remove a null action from an process definition");
+ throw new IllegalArgumentException("action is null");
}
if (actions != null) {
if (!actions.containsValue(action)) {
throw new IllegalArgumentException(
- "can't remove an action that is not part of this process definition");
+ "action is not present in process definition");
}
actions.remove(action.getName());
action.processDefinition = null;
@@ -417,8 +430,7 @@
}
public Action getAction(String name) {
- if (actions == null) return null;
- return (Action) actions.get(name);
+ return actions != null ? (Action) actions.get(name) : null;
}
public Map getActions() {
@@ -437,9 +449,9 @@
public ModuleDefinition addDefinition(ModuleDefinition moduleDefinition) {
if (moduleDefinition == null) {
- throw new IllegalArgumentException(
- "can't add a null moduleDefinition to a process definition");
+ throw new IllegalArgumentException("module definition is null");
}
+
if (definitions == null) definitions = new HashMap();
definitions.put(moduleDefinition.getClass().getName(), moduleDefinition);
moduleDefinition.setProcessDefinition(this);
@@ -447,11 +459,11 @@
}
public ModuleDefinition removeDefinition(ModuleDefinition moduleDefinition) {
- ModuleDefinition removedDefinition = null;
if (moduleDefinition == null) {
- throw new IllegalArgumentException(
- "can't remove a null moduleDefinition from a process definition");
+ throw new IllegalArgumentException("module definition is null");
}
+
+ ModuleDefinition removedDefinition = null;
if (definitions != null) {
removedDefinition = (ModuleDefinition) definitions.remove(moduleDefinition.getClass()
.getName());
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Transition.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Transition.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/def/Transition.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -44,7 +44,8 @@
// event types //////////////////////////////////////////////////////////////
- public static final String[] supportedEventTypes = new String[] { Event.EVENTTYPE_TRANSITION };
+ public static final String[] supportedEventTypes =
+ { Event.EVENTTYPE_TRANSITION };
public String[] getSupportedEventTypes() {
return supportedEventTypes;
@@ -66,8 +67,9 @@
}
/**
- * sets the from node unidirectionally. use {@link Node#addLeavingTransition(Transition)} to
- * get bidirectional relations mgmt.
+ * sets the from node unidirectionally. use
+ * {@link Node#addLeavingTransition(Transition)} to get bidirectional
+ * relations mgmt.
*/
public void setFrom(Node from) {
this.from = from;
@@ -76,8 +78,9 @@
// to ///////////////////////////////////////////////////////////////////////
/**
- * sets the to node unidirectionally. use {@link Node#addArrivingTransition(Transition)} to
- * get bidirectional relations mgmt.
+ * sets the to node unidirectionally. use
+ * {@link Node#addArrivingTransition(Transition)} to get bidirectional
+ * relations mgmt.
*/
public void setTo(Node to) {
this.to = to;
@@ -114,22 +117,25 @@
Token token = executionContext.getToken();
if (condition != null && isConditionEnforced) {
- Object result = JbpmExpressionEvaluator.evaluate(condition, executionContext);
+ Object result =
+ JbpmExpressionEvaluator.evaluate(condition, executionContext);
if (result == null) {
- throw new JbpmException("transition condition " + condition + " evaluated to null");
+ throw new JbpmException("transition condition " + condition
+ + " evaluated to null");
}
else if (!(result instanceof Boolean)) {
throw new JbpmException("transition condition " + condition
- + " evaluated to non-boolean: " + result.getClass().getName());
+ + " evaluated to non-boolean: " + result.getClass().getName());
}
- else if (!((Boolean) result).booleanValue()) {
- throw new JbpmException("transition condition " + condition + " evaluated to 'false'");
+ else if (((Boolean) result).booleanValue() == false) {
+ throw new JbpmException("transition condition " + condition
+ + " evaluated to 'false'");
}
}
// start the transition log
- TransitionLog transitionLog = new TransitionLog(this,
- executionContext.getTransitionSource());
+ TransitionLog transitionLog =
+ new TransitionLog(this, executionContext.getTransitionSource());
token.startCompositeLog(transitionLog);
try {
// fire leave events for superstates (if any)
@@ -156,23 +162,27 @@
Node destination = to;
while (destination != null && destination.isSuperStateNode()) {
List nodes = destination.getNodes();
- destination = nodes != null && !nodes.isEmpty() ? (Node) nodes.get(0) : null;
+ destination =
+ nodes != null && !nodes.isEmpty() ? (Node) nodes.get(0) : null;
}
if (destination == null) {
- String transitionName = (name != null ? "'" + name + "'" : "in node '" + from + "'");
+ String transitionName =
+ name != null ? '\'' + name + '\'' : "in node '" + from + '\'';
throw new JbpmException("transition " + transitionName
- + " doesn't have destination. check your processdefinition.xml");
+ + " has no destination");
}
// optimisation: check if there is a candidate superstate to be entered.
if (destination.getSuperState() != null) {
// collect all the superstates being left
List leavingSuperStates = collectAllSuperStates(destination, from);
- // reverse the order so that events are fired from outer to inner superstates
+ // reverse order so that events fire from outer to inner superstates
Collections.reverse(leavingSuperStates);
// fire a superstate-enter event for all superstates being left
- fireSuperStateEvents(leavingSuperStates, Event.EVENTTYPE_SUPERSTATE_ENTER, executionContext);
+ fireSuperStateEvents(leavingSuperStates,
+ Event.EVENTTYPE_SUPERSTATE_ENTER,
+ executionContext);
}
return destination;
@@ -182,9 +192,12 @@
// optimisation: check if there is a candidate superstate to be left.
if (executionContext.getTransitionSource().getSuperState() != null) {
// collect all the superstates being left
- List leavingSuperStates = collectAllSuperStates(executionContext.getTransitionSource(), to);
+ List leavingSuperStates =
+ collectAllSuperStates(executionContext.getTransitionSource(), to);
// fire a node-leave event for all superstates being left
- fireSuperStateEvents(leavingSuperStates, Event.EVENTTYPE_SUPERSTATE_LEAVE, executionContext);
+ fireSuperStateEvents(leavingSuperStates,
+ Event.EVENTTYPE_SUPERSTATE_LEAVE,
+ executionContext);
}
}
@@ -225,15 +238,15 @@
if (!(o instanceof Transition)) return false;
Transition other = (Transition) o;
- return id != 0 ? id == other.getId() : (name != null ? name.equals(other.getName())
+ if (id != 0 && id == other.getId()) return true;
+
+ return (name != null ? name.equals(other.getName())
: other.getName() == null)
- && (from != null ? from.equals(other.getFrom()) : other.getFrom() == null)
- && (to != null ? to.equals(other.getTo()) : other.getTo() == null);
+ && (from != null ? from.equals(other.getFrom()) : other.getFrom() == null)
+ && (to != null ? to.equals(other.getTo()) : other.getTo() == null);
}
public int hashCode() {
- if (id != 0) return (int) (id ^ (id >>> 32));
-
int result = 580399073 + (name != null ? name.hashCode() : 0);
result = 345105097 * result + (from != null ? from.hashCode() : 0);
result = 345105097 * result + (to != null ? to.hashCode() : 0);
@@ -248,10 +261,10 @@
if (from.hasLeavingTransition(name)) {
throw new IllegalArgumentException(
"couldn't set name '"
- + name
- + "' on transition '"
- + this
- + "'cause the from-node of this transition has already another leaving transition with the same name");
+ + name
+ + "' on transition '"
+ + this
+ + "'cause the from-node of this transition has already another leaving transition with the same name");
}
Map fromLeavingTransitions = from.getLeavingTransitionsMap();
fromLeavingTransitions.remove(this.name);
@@ -264,8 +277,10 @@
if (from != null && to != null) {
if (from.equals(to)) return from.getParent();
- for (GraphElement fromParent = from; fromParent != null; fromParent = fromParent.getParent()) {
- for (GraphElement toParent = to; toParent != null; toParent = toParent.getParent()) {
+ for (GraphElement fromParent = from; fromParent != null; fromParent =
+ fromParent.getParent()) {
+ for (GraphElement toParent = to; toParent != null; toParent =
+ toParent.getParent()) {
if (fromParent.equals(toParent)) return fromParent;
}
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Comment.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Comment.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Comment.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -26,78 +26,108 @@
import org.jbpm.security.SecurityHelper;
import org.jbpm.taskmgmt.exe.TaskInstance;
-import org.jbpm.util.EqualsUtil;
public class Comment implements Serializable {
private static final long serialVersionUID = 1L;
- long id = 0;
- int version = 0;
- protected String actorId = null;
- protected Date time = null;
- protected String message = null;
- protected Token token = null;
- protected TaskInstance taskInstance = null;
+ long id;
+ int version;
+ protected String actorId;
+ protected Date time;
+ protected String message;
+ protected Token token;
+ protected TaskInstance taskInstance;
public Comment() {
}
-
+
public Comment(String message) {
this.actorId = SecurityHelper.getAuthenticatedActorId();
this.time = new Date();
this.message = message;
}
-
+
public Comment(String actorId, String message) {
this.actorId = actorId;
this.time = new Date();
this.message = message;
}
-
+
public String toString() {
- return "comment("+(actorId!=null ? actorId+"|" : "")+message+")";
+ return "Comment(" + message + ')';
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof Comment)) return false;
+
+ Comment other = (Comment) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return message.equals(other.getMessage())
+ && (actorId != null ? actorId.equals(other.getActorId())
+ : other.getActorId() == null)
+ && (taskInstance != null ? taskInstance.equals(other.getTaskInstance())
+ : token != null ? token.equals(other.getToken()) : false);
}
+ public int hashCode() {
+ int result = 769046417 + message.hashCode();
+ result = 1770536419 * result + actorId != null ? actorId.hashCode() : 0;
+ if (taskInstance != null) {
+ result = 55354751 * result + taskInstance.hashCode();
+ }
+ else if (token != null) {
+ result = 55354751 * result + token.hashCode();
+ }
+ return result;
+ }
+
// getters and setters //////////////////////////////////////////////////////
-
+
public String getActorId() {
return actorId;
}
+
public long getId() {
return id;
}
+
public String getMessage() {
return message;
}
+
public Date getTime() {
return time;
}
+
public TaskInstance getTaskInstance() {
return taskInstance;
}
+
public Token getToken() {
return token;
}
+
public void setTaskInstance(TaskInstance taskInstance) {
this.taskInstance = taskInstance;
}
+
public void setToken(Token token) {
this.token = token;
}
+
public void setActorId(String actorId) {
this.actorId = actorId;
}
+
public void setMessage(String message) {
this.message = message;
}
+
public void setTime(Date time) {
this.time = time;
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/ProcessInstance.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -52,8 +52,9 @@
import org.jbpm.util.Clock;
/**
- * is one execution of a {@link org.jbpm.graph.def.ProcessDefinition}. To create a new process
- * execution of a process definition, just use the {@link #ProcessInstance(ProcessDefinition)}.
+ * is one execution of a {@link org.jbpm.graph.def.ProcessDefinition}. To create
+ * a new process execution of a process definition, just use the
+ * {@link #ProcessInstance(ProcessDefinition)}.
*/
public class ProcessInstance implements Identifiable, Serializable {
@@ -80,11 +81,12 @@
}
/**
- * creates a new process instance for the given process definition, puts the root-token (=main
- * path of execution) in the start state and executes the initial node. In case the initial
- * node is a start-state, it will behave as a wait state. For each of the optional module
- * definitions contained in the {@link ProcessDefinition}, the corresponding module instance
- * will be created.
+ * creates a new process instance for the given process definition, puts the
+ * root-token (=main path of execution) in the start state and executes the
+ * initial node. In case the initial node is a start-state, it will behave as
+ * a wait state. For each of the optional module definitions contained in the
+ * {@link ProcessDefinition}, the corresponding module instance will be
+ * created.
*
* @throws JbpmException if processDefinition is null.
*/
@@ -93,15 +95,16 @@
}
/**
- * creates a new process instance for the given process definition, puts the root-token (=main
- * path of execution) in the start state and executes the initial node. In case the initial
- * node is a start-state, it will behave as a wait state. For each of the optional module
- * definitions contained in the {@link ProcessDefinition}, the corresponding module instance
- * will be created.
+ * creates a new process instance for the given process definition, puts the
+ * root-token (=main path of execution) in the start state and executes the
+ * initial node. In case the initial node is a start-state, it will behave as
+ * a wait state. For each of the optional module definitions contained in the
+ * {@link ProcessDefinition}, the corresponding module instance will be
+ * created.
*
- * @param variables will be inserted into the context variables after the context submodule
- * has been created and before the process-start event is fired, which is also before
- * the execution of the initial node.
+ * @param variables will be inserted into the context variables after the
+ * context submodule has been created and before the process-start event is
+ * fired, which is also before the execution of the initial node.
* @throws JbpmException if processDefinition is null.
*/
public ProcessInstance(ProcessDefinition processDefinition, Map variables) {
@@ -109,27 +112,29 @@
}
/**
- * creates a new process instance for the given process definition, puts the root-token (=main
- * path of execution) in the start state and executes the initial node. In case the initial
- * node is a start-state, it will behave as a wait state. For each of the optional module
- * definitions contained in the {@link ProcessDefinition}, the corresponding module instance
- * will be created.
+ * creates a new process instance for the given process definition, puts the
+ * root-token (=main path of execution) in the start state and executes the
+ * initial node. In case the initial node is a start-state, it will behave as
+ * a wait state. For each of the optional module definitions contained in the
+ * {@link ProcessDefinition}, the corresponding module instance will be
+ * created.
*
- * @param variables will be inserted into the context variables after the context submodule
- * has been created and before the process-start event is fired, which is also before
- * the execution of the initial node.
+ * @param variables will be inserted into the context variables after the
+ * context submodule has been created and before the process-start event is
+ * fired, which is also before the execution of the initial node.
* @throws JbpmException if processDefinition is null.
*/
- public ProcessInstance(ProcessDefinition processDefinition, Map variables, String key) {
+ public ProcessInstance(ProcessDefinition processDefinition, Map variables,
+ String key) {
if (processDefinition == null) {
- throw new JbpmException("can't create a process instance when processDefinition is null");
+ throw new IllegalArgumentException("process definition is null");
}
// initialize the members
this.processDefinition = processDefinition;
this.rootToken = new Token(this);
this.key = key;
- // if this process instance is created in the context of a persistent operation
+ // if this is created in the context of a persistent operation
Services.assignId(this);
// create the optional definitions
@@ -175,7 +180,8 @@
// fire the process start event
if (initialNode != null) {
ExecutionContext executionContext = new ExecutionContext(rootToken);
- processDefinition.fireEvent(Event.EVENTTYPE_PROCESS_START, executionContext);
+ processDefinition.fireEvent(Event.EVENTTYPE_PROCESS_START,
+ executionContext);
// execute the start node
initialNode.execute(executionContext);
@@ -189,9 +195,9 @@
*/
public ModuleInstance addInstance(ModuleInstance moduleInstance) {
if (moduleInstance == null) {
- throw new IllegalArgumentException(
- "can't add a null moduleInstance to a process instance");
+ throw new IllegalArgumentException("module instance is null");
}
+
if (instances == null) instances = new HashMap();
instances.put(moduleInstance.getClass().getName(), moduleInstance);
moduleInstance.setProcessInstance(this);
@@ -202,11 +208,11 @@
* removes the given optional moduleinstance (bidirectional).
*/
public ModuleInstance removeInstance(ModuleInstance moduleInstance) {
- ModuleInstance removedModuleInstance = null;
if (moduleInstance == null) {
- throw new IllegalArgumentException(
- "can't remove a null moduleInstance from a process instance");
+ throw new IllegalArgumentException("module instance is null");
}
+
+ ModuleInstance removedModuleInstance = null;
if (instances != null) {
removedModuleInstance = (ModuleInstance) instances.remove(moduleInstance.getClass()
.getName());
@@ -222,8 +228,9 @@
*/
public ModuleInstance getInstance(Class clazz) {
ModuleInstance moduleInstance = null;
+ String className = clazz.getName();
if (instances != null) {
- moduleInstance = (ModuleInstance) instances.get(clazz.getName());
+ moduleInstance = (ModuleInstance) instances.get(className);
}
if (moduleInstance == null) {
@@ -231,18 +238,21 @@
// client requested an instance that is not in the map of instances.
// so we can safely assume that the client wants a transient instance
- moduleInstance = (ModuleInstance) transientInstances.get(clazz.getName());
+ moduleInstance = (ModuleInstance) transientInstances.get(className);
if (moduleInstance == null) {
try {
moduleInstance = (ModuleInstance) clazz.newInstance();
moduleInstance.setProcessInstance(this);
-
}
- catch (Exception e) {
- throw new JbpmException("couldn't instantiate transient module '" + clazz.getName()
- + "' with the default constructor");
+ catch (InstantiationException e) {
+ throw new JbpmException("could not instantiate transient module "
+ + className, e);
}
- transientInstances.put(clazz.getName(), moduleInstance);
+ catch (IllegalAccessException e) {
+ throw new JbpmException("could not access transient module "
+ + className, e);
+ }
+ transientInstances.put(className, moduleInstance);
}
}
@@ -264,9 +274,9 @@
}
/**
- * process instance extension for logging. Probably you don't need to access the logging
- * instance directly. Mostly, {@link Token#addLog(ProcessLog)} is sufficient and more
- * convenient.
+ * process instance extension for logging. Probably you don't need to access
+ * the logging instance directly. Mostly, {@link Token#addLog(ProcessLog)} is
+ * sufficient and more convenient.
*/
public LoggingInstance getLoggingInstance() {
return (LoggingInstance) getInstance(LoggingInstance.class);
@@ -275,40 +285,40 @@
// operations ///////////////////////////////////////////////////////////////
/**
- * instructs the main path of execution to continue by taking the default transition on the
- * current node.
+ * instructs the main path of execution to continue by taking the default
+ * transition on the current node.
*
* @throws IllegalStateException if the token is not active.
*/
public void signal() {
if (hasEnded()) {
- throw new IllegalStateException("couldn't signal token : token has ended");
+ throw new IllegalStateException("token has ended");
}
rootToken.signal();
}
/**
- * instructs the main path of execution to continue by taking the specified transition on the
- * current node.
+ * instructs the main path of execution to continue by taking the specified
+ * transition on the current node.
*
* @throws IllegalStateException if the token is not active.
*/
public void signal(String transitionName) {
if (hasEnded()) {
- throw new IllegalStateException("couldn't signal token : token has ended");
+ throw new IllegalStateException("token has ended");
}
rootToken.signal(transitionName);
}
/**
- * instructs the main path of execution to continue by taking the specified transition on the
- * current node.
+ * instructs the main path of execution to continue by taking the specified
+ * transition on the current node.
*
* @throws IllegalStateException if the token is not active.
*/
public void signal(Transition transition) {
if (hasEnded()) {
- throw new IllegalStateException("couldn't signal token : token has ended");
+ throw new IllegalStateException("token has ended");
}
rootToken.signal(transition);
}
@@ -335,7 +345,8 @@
if (superProcessToken != null && !superProcessToken.hasEnded()) {
addCascadeProcessInstance(superProcessToken.getProcessInstance());
- ExecutionContext superExecutionContext = new ExecutionContext(superProcessToken);
+ ExecutionContext superExecutionContext = new ExecutionContext(
+ superProcessToken);
superExecutionContext.setSubProcessInstance(this);
superProcessToken.signal(superExecutionContext);
}
@@ -348,8 +359,9 @@
MessageService messageService = services.getMessageService();
PersistenceService persistenceService = services.getPersistenceService();
if (messageService != null
- && persistenceService != null
- && persistenceService.getJobSession().countDeletableJobsForProcessInstance(this) > 0) {
+ && persistenceService != null
+ && persistenceService.getJobSession()
+ .countDeletableJobsForProcessInstance(this) > 0) {
CleanUpProcessJob job = new CleanUpProcessJob(rootToken);
job.setDueDate(new Date());
messageService.send(job);
@@ -359,8 +371,9 @@
}
/**
- * suspends this execution. This will make sure that tasks, timers and messages related to
- * this process instance will not show up in database queries.
+ * suspends this execution. This will make sure that tasks, timers and
+ * messages related to this process instance will not show up in database
+ * queries.
*
* @see #resume()
*/
@@ -370,10 +383,10 @@
}
/**
- * resumes a suspended execution. All timers that have been suspended might fire if the
- * duedate has been passed. If an admin resumes a process instance, the option should be
- * offered to update, remove and create the timers and messages related to this process
- * instance.
+ * resumes a suspended execution. All timers that have been suspended might
+ * fire if the duedate has been passed. If an admin resumes a process
+ * instance, the option should be offered to update, remove and create the
+ * timers and messages related to this process instance.
*
* @see #suspend()
*/
@@ -389,7 +402,7 @@
*/
public RuntimeAction addRuntimeAction(RuntimeAction runtimeAction) {
if (runtimeAction == null) {
- throw new IllegalArgumentException("can't add a null runtimeAction to a process instance");
+ throw new IllegalArgumentException("runtime action is null");
}
if (runtimeActions == null) runtimeActions = new ArrayList();
runtimeActions.add(runtimeAction);
@@ -403,8 +416,7 @@
public RuntimeAction removeRuntimeAction(RuntimeAction runtimeAction) {
RuntimeAction removedRuntimeAction = null;
if (runtimeAction == null) {
- throw new IllegalArgumentException(
- "can't remove a null runtimeAction from an process instance");
+ throw new IllegalArgumentException("runtime action is null");
}
if (runtimeActions != null) {
if (runtimeActions.remove(runtimeAction)) {
@@ -443,9 +455,11 @@
}
/**
- * looks up the token in the tree, specified by the slash-separated token path.
+ * looks up the token in the tree, specified by the slash-separated token
+ * path.
*
- * @param tokenPath is a slash-separated name that specifies a token in the tree.
+ * @param tokenPath is a slash-separated name that specifies a token in the
+ * tree.
* @return the specified token or null if the token is not found.
*/
public Token findToken(String tokenPath) {
@@ -482,23 +496,24 @@
if (!(o instanceof ProcessInstance)) return false;
ProcessInstance other = (ProcessInstance) o;
- return id != 0 ? id == other.getId() : (key != null ? key.equals(other.getKey())
- : other.getKey() == null)
- && processDefinition.equals(other.getProcessDefinition());
+ if (id != 0 && id == other.getId()) return true;
+
+ return key != null && key.equals(other.getKey())
+ && processDefinition.equals(other.getProcessDefinition());
}
public int hashCode() {
- if (id != 0) return (int) (id ^ (id >>> 32));
+ if (key == null) return super.hashCode();
- int result = 295436291 + (key != null ? key.hashCode() : 0);
+ int result = 295436291 + key.hashCode();
result = 1367411281 * result + processDefinition.hashCode();
return result;
}
public String toString() {
return "ProcessInstance"
- + (key != null ? '(' + key + ')' : id != 0 ? "(" + id + ')'
- : '@' + Integer.toHexString(hashCode()));
+ + (key != null ? '(' + key + ')' : id != 0 ? "(" + id + ')'
+ : '@' + Integer.toHexString(hashCode()));
}
// getters and setters //////////////////////////////////////////////////////
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/RuntimeAction.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/RuntimeAction.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/RuntimeAction.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -21,32 +21,35 @@
*/
package org.jbpm.graph.exe;
-import java.io.*;
+import java.io.Serializable;
-import org.jbpm.graph.def.*;
-import org.jbpm.util.EqualsUtil;
+import org.jbpm.graph.def.Action;
+import org.jbpm.graph.def.Event;
+import org.jbpm.graph.def.GraphElement;
+import org.jbpm.graph.def.ProcessDefinition;
/**
- * is an action that can be added at runtime to the execution of one process instance.
+ * is an action added at runtime to the execution of one process instance.
*/
public class RuntimeAction implements Serializable {
-
+
private static final long serialVersionUID = 1L;
-
- long id = 0;
- int version = 0;
- protected ProcessInstance processInstance = null;
- protected GraphElement graphElement = null;
- protected String eventType = null;
- protected Action action = null;
-
+
+ long id;
+ int version;
+ protected ProcessInstance processInstance;
+ protected GraphElement graphElement;
+ protected String eventType;
+ protected Action action;
+
public RuntimeAction() {
}
/**
- * creates a runtime action. Look up the event with {@link GraphElement#getEvent(String)}
- * and the action with {@link ProcessDefinition#getAction(String)}. You can only
- * lookup named actions easily.
+ * creates a runtime action. Look up the event with
+ * {@link GraphElement#getEvent(String)} and the action with
+ * {@link ProcessDefinition#getAction(String)}. You can only lookup named
+ * actions easily.
*/
public RuntimeAction(Event event, Action action) {
this.graphElement = event.getGraphElement();
@@ -54,33 +57,52 @@
this.action = action;
}
- public RuntimeAction(GraphElement graphElement, String eventType, Action action) {
+ public RuntimeAction(GraphElement graphElement, String eventType,
+ Action action) {
this.graphElement = graphElement;
this.eventType = eventType;
this.action = action;
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof Event)) return false;
+
+ RuntimeAction other = (RuntimeAction) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return eventType.equals(other.getEventType())
+ && graphElement.equals(other.getGraphElement())
+ && processInstance.equals(other.getProcessInstance());
}
-
+
+ public int hashCode() {
+ int result = 560044783 + eventType.hashCode();
+ result = 279308149 * result + graphElement.hashCode();
+ result = 106268467 * result + processInstance.hashCode();
+ return result;
+ }
+
// getters and setters //////////////////////////////////////////////////////
public long getId() {
return id;
}
+
public ProcessInstance getProcessInstance() {
return processInstance;
}
+
public Action getAction() {
return action;
}
+
public String getEventType() {
return eventType;
}
+
public GraphElement getGraphElement() {
return graphElement;
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Token.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Token.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/graph/exe/Token.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -55,8 +55,8 @@
/**
* represents one path of execution and maintains a pointer to a node in the
- * {@link org.jbpm.graph.def.ProcessDefinition}. Most common way to get a hold of the token
- * objects is with {@link ProcessInstance#getRootToken()} or
+ * {@link org.jbpm.graph.def.ProcessDefinition}. Most common way to get a hold
+ * of the token objects is with {@link ProcessInstance#getRootToken()} or
* {@link org.jbpm.graph.exe.ProcessInstance#findToken(String)}.
*/
public class Token implements Identifiable, Serializable {
@@ -94,7 +94,8 @@
this.start = Clock.getCurrentTime();
this.processInstance = processInstance;
this.node = processInstance.getProcessDefinition().getStartState();
- this.isTerminationImplicit = processInstance.getProcessDefinition().isTerminationImplicit();
+ this.isTerminationImplicit = processInstance.getProcessDefinition()
+ .isTerminationImplicit();
// assign an id to this token before events get fired
Services.assignId(this);
@@ -128,29 +129,26 @@
}
/**
- * provides a signal to the token. this method activates this token and leaves the current
- * state over the default transition.
+ * provides a signal to the token. this method activates this token and leaves
+ * the current state over the default transition.
*/
public void signal() {
if (node == null) {
- throw new JbpmException("token '" + this
- + "' can't be signalled cause it is currently not positioned in a node");
+ throw new JbpmException(this + " is not positioned in a node");
}
if (node.getDefaultLeavingTransition() == null) {
- throw new JbpmException("couldn't signal " + this + " : node " + node
- + " has no default transition");
+ throw new JbpmException(node + " has no default transition");
}
signal(node.getDefaultLeavingTransition(), new ExecutionContext(this));
}
/**
- * Provides a signal to the token. This leave the current state over the given transition
- * name.
+ * Provides a signal to the token. This leave the current state over the given
+ * transition name.
*/
public void signal(String transitionName) {
if (node == null) {
- throw new JbpmException("token '" + this
- + "' can't be signalled cause it is currently not positioned in a node");
+ throw new JbpmException(this + "' is not positioned in a node");
}
Transition leavingTransition = node.getLeavingTransition(transitionName);
@@ -166,15 +164,17 @@
}
}
- if (leavingTransition == null)
- throw new JbpmException("transition '" + transitionName + "' does not exist on " + node);
+ if (leavingTransition == null) {
+ throw new JbpmException(node + " has no leaving transition named "
+ + transitionName);
+ }
signal(leavingTransition, new ExecutionContext(this));
}
/**
- * provides a signal to the token. this leave the current state over the given transition
- * name.
+ * provides a signal to the token. this leave the current state over the given
+ * transition name.
*/
public void signal(Transition transition) {
signal(transition, new ExecutionContext(this));
@@ -190,18 +190,16 @@
"couldn't signal without specifying a leaving transition : transition is null");
}
if (executionContext == null) {
- throw new JbpmException(
- "couldn't signal without an execution context: executionContext is null");
+ throw new JbpmException("execution context is null");
}
if (isSuspended) {
- throw new JbpmException("can't signal token '" + name + "' (" + id + "): it is suspended");
+ throw new JbpmException("token is suspended");
}
if (isLocked()) {
- throw new JbpmException("this token is locked by " + lock);
+ throw new JbpmException("token is locked by " + lock);
}
if (hasEnded()) {
- throw new JbpmException("Token '" + name + "' (" + id
- + ") is already ended and cannot be signaled");
+ throw new JbpmException("token has ended");
}
startCompositeLog(new SignalLog(transition));
@@ -226,8 +224,8 @@
}
/**
- * a set of all the leaving transitions on the current node for which the condition expression
- * resolves to true.
+ * a set of all the leaving transitions on the current node for which the
+ * condition expression resolves to true.
*/
public Set getAvailableTransitions() {
Set availableTransitions = new HashSet();
@@ -238,10 +236,11 @@
}
/**
- * adds available transitions of that node to the Set and after that calls itself recursivly
- * for the SuperSate of the Node if it has a super state
+ * adds available transitions of that node to the Set and after that calls
+ * itself recursivly for the SuperSate of the Node if it has a super state
*/
- private void addAvailableTransitionsOfNode(Node currentNode, Set availableTransitions) {
+ private void addAvailableTransitionsOfNode(Node currentNode,
+ Set availableTransitions) {
List leavingTransitions = currentNode.getLeavingTransitions();
if (leavingTransitions != null) {
Iterator iter = leavingTransitions.iterator();
@@ -249,9 +248,10 @@
Transition transition = (Transition) iter.next();
String conditionExpression = transition.getCondition();
if (conditionExpression != null) {
- Object result = JbpmExpressionEvaluator.evaluate(conditionExpression, new ExecutionContext(
- this));
- if ((result instanceof Boolean) && (((Boolean) result).booleanValue())) {
+ Object result = JbpmExpressionEvaluator.evaluate(conditionExpression,
+ new ExecutionContext(this));
+ if ((result instanceof Boolean)
+ && (((Boolean) result).booleanValue())) {
availableTransitions.add(transition);
}
}
@@ -261,14 +261,15 @@
}
}
if (currentNode.getSuperState() != null) {
- addAvailableTransitionsOfNode(currentNode.getSuperState(), availableTransitions);
+ addAvailableTransitionsOfNode(currentNode.getSuperState(),
+ availableTransitions);
}
}
/**
- * ends this token and all of its children (if any). this is the last active (=not-ended)
- * child of a parent token, the parent token will be ended as well and that verification will
- * continue to propagate.
+ * ends this token and all of its children (if any). this is the last active
+ * (=not-ended) child of a parent token, the parent token will be ended as
+ * well and that verification will continue to propagate.
*/
public void end() {
end(true);
@@ -277,10 +278,10 @@
/**
* ends this token with optional parent ending verification.
*
- * @param verifyParentTermination specifies if the parent token should be checked for
- * termination. if verifyParentTermination is set to true and this is the last
- * non-ended child of a parent token, the parent token will be ended as well and the
- * verification will continue to propagate.
+ * @param verifyParentTermination specifies if the parent token should be
+ * checked for termination. if verifyParentTermination is set to true and this
+ * is the last non-ended child of a parent token, the parent token will be
+ * ended as well and the verification will continue to propagate.
*/
public void end(boolean verifyParentTermination) {
// if not already ended
@@ -308,13 +309,15 @@
subProcessInstance.end();
}
- // only log child-token ends. process instance logs replace root token logs.
+ // only log child-token ends. process instance logs replace root token
+ // logs.
if (parent != null) {
// add a log
parent.addLog(new TokenEndLog(this));
}
- // if there are tasks associated to this token, remove signaling capabilities
+ // if there are tasks associated to this token, remove signaling
+ // capabilities
TaskMgmtInstance taskMgmtInstance = (processInstance != null ? processInstance.getTaskMgmtInstance()
: null);
if (taskMgmtInstance != null) {
@@ -354,11 +357,8 @@
if (isRoot()) {
processInstance.end();
}
- else {
-
- if (!parent.hasActiveChildren()) {
- parent.end();
- }
+ else if (!parent.hasActiveChildren()) {
+ parent.end();
}
}
@@ -395,8 +395,8 @@
}
/**
- * convenience method for starting a composite log. When you add composite logs, make sure you
- * put the {@link #endCompositeLog()} in a finally block.
+ * convenience method for starting a composite log. When you add composite
+ * logs, make sure you put the {@link #endCompositeLog()} in a finally block.
*/
public void startCompositeLog(CompositeLog compositeLog) {
LoggingInstance li = (LoggingInstance) processInstance.getInstance(LoggingInstance.class);
@@ -407,7 +407,8 @@
}
/**
- * convenience method for ending a composite log. Make sure you put this in a finally block.
+ * convenience method for ending a composite log. Make sure you put this in a
+ * finally block.
*/
public void endCompositeLog() {
LoggingInstance li = (LoggingInstance) processInstance.getInstance(LoggingInstance.class);
@@ -584,7 +585,8 @@
void suspendJobs() {
JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext();
- JobSession jobSession = (jbpmContext != null ? jbpmContext.getJobSession() : null);
+ JobSession jobSession = jbpmContext != null ? jbpmContext.getJobSession()
+ : null;
if (jobSession != null) {
jobSession.suspendJobs(this);
}
@@ -619,7 +621,8 @@
void resumeJobs() {
JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext();
- JobSession jobSession = (jbpmContext != null ? jbpmContext.getJobSession() : null);
+ JobSession jobSession = jbpmContext != null ? jbpmContext.getJobSession()
+ : null;
if (jobSession != null) {
jobSession.resumeJobs(this);
}
@@ -640,18 +643,18 @@
if (!(o instanceof Token)) return false;
Token other = (Token) o;
- return id != 0 ? id == other.getId() : (name != null ? name.equals(other.getName())
+ if (id != 0 && id == other.getId()) return true;
+
+ return (name != null ? name.equals(other.getName())
: other.getName() == null)
- && (parent != null ? parent.equals(other.getParent())
- : processInstance.equals(other.getProcessInstance()));
+ && (parent != null ? parent.equals(other.getParent())
+ : processInstance.equals(other.getProcessInstance()));
}
public int hashCode() {
- if (id != 0) return (int) (id ^ (id >>> 32));
-
int result = 2080763213 + (name != null ? name.hashCode() : 0);
result = 1076685199 * result
- + (parent != null ? parent.hashCode() : processInstance.hashCode());
+ + (parent != null ? parent.hashCode() : processInstance.hashCode());
return result;
}
@@ -659,7 +662,8 @@
return "Token(" + getFullName() + ')';
}
- public ProcessInstance createSubProcessInstance(ProcessDefinition subProcessDefinition) {
+ public ProcessInstance createSubProcessInstance(
+ ProcessDefinition subProcessDefinition) {
// create the new sub process instance
subProcessInstance = new ProcessInstance(subProcessDefinition);
// bind the subprocess to the super-process-token
@@ -671,56 +675,79 @@
}
/**
- * locks a process instance for further execution. A locked token cannot continue execution.
- * This is a non-persistent operation. This is used to prevent tokens being propagated during
- * the execution of actions.
+ * locks a process instance for further execution. A locked token cannot
+ * continue execution. This is a non-persistent operation. This is used to
+ * prevent tokens being propagated during the execution of actions.
*
* @see #unlock(String)
*/
public void lock(String lockOwnerId) {
if (lockOwnerId == null) {
- throw new JbpmException("can't lock with null value for the lockOwnerId");
+ throw new JbpmException("lock owner is null");
}
- if ((lock != null) && (!lock.equals(lockOwnerId))) {
- throw new JbpmException(this + " cannot be locked by '" + lockOwnerId
- + "' because it is already locked by '" + lock + "'");
+
+ if (lock == null) {
+ lock = lockOwnerId;
+ log.debug('\'' + lockOwnerId + "' locked " + this);
}
- log.debug("token[" + id + "] is locked by " + lockOwnerId);
- lock = lockOwnerId;
+ else if (!lock.equals(lockOwnerId)) {
+ throw new JbpmException('\'' + lockOwnerId + "' cannot lock " + this
+ + " because '" + lock + "' already locked it");
+ }
}
/**
* @see #lock(String)
*/
public void unlock(String lockOwnerId) {
- if (lock == null) {
- log.warn("lock owner '" + lockOwnerId + "' tries to unlock token '" + id
- + "' which is not locked");
+ if (lock != null) {
+ if (!lock.equals(lockOwnerId)) {
+ throw new JbpmException('\'' + lockOwnerId + "' cannot unlock " + this
+ + " because '" + lock + "' locked it");
+ }
+ lock = null;
+ log.debug('\'' + lockOwnerId + "' unlocked " + this);
}
- else if (!lock.equals(lockOwnerId)) {
- throw new JbpmException("'" + lockOwnerId + "' can't unlock token '" + id
- + "' because it was already locked by '" + lock + "'");
+ else {
+ log.warn(this + " was unlocked already");
}
- log.debug("token[" + id + "] is unlocked by " + lockOwnerId);
- lock = null;
}
/**
- * force unlocking the token, even if the owner is not known. In some use cases (e.g. in the
- * jbpm esb integration) the lock is persistent, so a state can be reached where the client
- * needs a possibility to force unlock of a token without knowing the owner. See
- * https://jira.jboss.org/jira/browse/JBPM-1888
+ * force unlocking the token, even if the owner is not known. In some use
+ * cases (e.g. in the jbpm esb integration) the lock is persistent, so a state
+ * can be reached where the client needs a possibility to force unlock of a
+ * token without knowing the owner.
+ *
+ * @see <a href="https://jira.jboss.org/jira/browse/JBPM-1888">JBPM-1888</a>
+ * @deprecated Use {@link #forceUnlock()} instead
*/
public void foreUnlock() {
- if (lock == null) {
- log.warn("Unlock of token '" + id + "' forced, but it is not locked");
+ forceUnlock();
+ }
+
+ /**
+ * force unlocking the token, even if the owner is not known. In some use
+ * cases (e.g. in the jbpm esb integration) the lock is persistent, so a state
+ * can be reached where the client needs a possibility to force unlock of a
+ * token without knowing the owner.
+ *
+ * @see <a href="https://jira.jboss.org/jira/browse/JBPM-1888">JBPM-1888</a>
+ */
+ public void forceUnlock() {
+ if (lock != null) {
+ lock = null;
+ log.debug("forcefully unlocked " + this);
}
- log.debug("Foce unlock of token[" + id + "] which was locked by " + lock);
- lock = null;
+ else {
+ log.warn(this + " was unlocked already");
+ }
}
/**
- * return the current lock owner of the token See https://jira.jboss.org/jira/browse/JBPM-1888
+ * return the current lock owner of the token
+ *
+ * @see <a href="https://jira.jboss.org/jira/browse/JBPM-1888">JBPM-1888</a>
*/
public String getLockOwner() {
return lock;
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/instantiation/Delegation.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/instantiation/Delegation.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/instantiation/Delegation.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -41,7 +41,7 @@
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.jpdl.xml.JpdlXmlReader;
import org.jbpm.jpdl.xml.Parsable;
-import org.jbpm.util.EqualsUtil;
+import org.jbpm.jpdl.xml.Problem;
public class Delegation implements Parsable, Serializable {
@@ -55,7 +55,8 @@
instantiators.put("field", new FieldInstantiator());
instantiators.put("bean", new BeanInstantiator());
instantiators.put("constructor", new ConstructorInstantiator());
- instantiators.put("configuration-property", new ConfigurationPropertyInstantiator());
+ instantiators.put("configuration-property",
+ new ConfigurationPropertyInstantiator());
instantiators.put("xml", new XmlInstantiator());
return instantiators;
}
@@ -89,8 +90,10 @@
if (delegateElement.hasContent()) {
try {
StringWriter stringWriter = new StringWriter();
- // when parsing, it could be to store the config in the database, so we want to make the configuration compact
- XMLWriter xmlWriter = new XMLWriter(stringWriter, OutputFormat.createCompactFormat());
+ // when parsing, it could be to store the config in the database,
+ // so we want to make the configuration compact
+ XMLWriter xmlWriter = new XMLWriter(stringWriter,
+ OutputFormat.createCompactFormat());
for (Iterator iter = delegateElement.content().iterator(); iter.hasNext();) {
Object node = iter.next();
xmlWriter.write(node);
@@ -99,8 +102,8 @@
configuration = stringWriter.toString();
}
catch (IOException e) {
- jpdlReader.addWarning("io problem while parsing the configuration of "
- + delegateElement.asXML());
+ jpdlReader.addProblem(new Problem(Problem.LEVEL_WARNING,
+ "failed to write configuration xml", e));
}
}
}
@@ -111,12 +114,12 @@
String configuration = this.configuration;
if (configuration != null) {
try {
- Element actionElement = DocumentHelper.parseText("<action>" + configuration + "</action>")
- .getRootElement();
+ Element actionElement = DocumentHelper.parseText(
+ "<action>" + configuration + "</action>").getRootElement();
element.appendContent(actionElement);
}
catch (DocumentException e) {
- log.error("couldn't create dom-tree for action configuration '" + configuration + "'", e);
+ log.error("could not parse action configuration: " + configuration, e);
}
}
}
@@ -130,10 +133,10 @@
public Object instantiate() {
// The thread class loader was set before the instantiation correctly
- // to the ProcessClassLoader which can be directly used here
+ // to the ProcessClassLoader (PCL) which can be directly used here
// If we would construct a JbpmConfiguration.getProcessClassLoder here
- // we would have the hierarchy ProcessClassLoader -> ProcessClassLoader -> Context...
- // this is one ProcessClassLoader too much
+ // we would have the hierarchy PCL -> PCL -> Context...
+ // this is one PCL too much
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
// find the instantiator
@@ -147,7 +150,8 @@
instantiatorCache.put(configType, instantiator);
}
catch (ClassNotFoundException e) {
- throw new JbpmException("could not load instantiator class '" + configType + "'", e);
+ throw new JbpmException("could not load instantiator class "
+ + configType, e);
}
catch (InstantiationException e) {
throw new JbpmException("could not instantiate " + configType, e);
@@ -164,17 +168,36 @@
return instantiator.instantiate(delegationClass, configuration);
}
catch (ClassNotFoundException e) {
- throw new DelegationException("could not load delegation class '" + className + "'", e);
+ throw new DelegationException("could not load delegation class "
+ + className, e);
}
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof Delegation)) return false;
+
+ Delegation other = (Delegation) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return className.equals(other.getClassName())
+ && (configuration != null ? configuration.equals(other.getConfiguration())
+ : other.getConfiguration() == null);
}
+ public int hashCode() {
+ int result = 2131399759 + className.hashCode();
+ result = 702058657 * result + configuration != null ? configuration.hashCode()
+ : 0;
+ return result;
+ }
+
+ public String toString() {
+ return "Delegation(" + className + ')';
+ }
+
// getters and setters //////////////////////////////////////////////////////
public String getClassName() {
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/def/ModuleDefinition.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/def/ModuleDefinition.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/def/ModuleDefinition.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -25,12 +25,11 @@
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.module.exe.ModuleInstance;
-import org.jbpm.util.EqualsUtil;
public abstract class ModuleDefinition implements Serializable {
long id;
- protected String name;
+ protected String name; // name equals fully qualified class name
protected ProcessDefinition processDefinition;
private static final long serialVersionUID = 1L;
@@ -42,12 +41,24 @@
public abstract ModuleInstance createInstance();
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof ModuleDefinition)) return false;
+
+ ModuleDefinition other = (ModuleDefinition) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return name.equals(other.getName())
+ && processDefinition.equals(other.getProcessDefinition());
}
+ public int hashCode() {
+ int result = 2122701961 + name.hashCode();
+ result = 1574886923 * result + processDefinition.hashCode();
+ return result;
+ }
+
// getters and setters //////////////////////////////////////////////////////
public long getId() {
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/exe/ModuleInstance.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/exe/ModuleInstance.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/module/exe/ModuleInstance.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -26,43 +26,56 @@
import org.jbpm.JbpmContext;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.svc.Service;
-import org.jbpm.util.EqualsUtil;
public class ModuleInstance implements Serializable {
-
+
private static final long serialVersionUID = 1L;
-
- long id = 0;
- int version = 0;
- protected ProcessInstance processInstance = null;
-
+
+ long id;
+ int version;
+ protected ProcessInstance processInstance;
+
public ModuleInstance() {
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof ModuleInstance)) return false;
+
+ ModuleInstance other = (ModuleInstance) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return getClass().getName().equals(other.getClass().getName())
+ && processInstance.equals(other.getProcessInstance());
}
-
+
+ public int hashCode() {
+ int result = 1849786963 + getClass().getName().hashCode();
+ result = 1566965963 * result + processInstance.hashCode();
+ return result;
+ }
+
protected Service getService(String serviceName) {
Service service = null;
JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext();
- if (jbpmContext!=null) {
+ if (jbpmContext != null) {
service = jbpmContext.getServices().getService(serviceName);
}
- return service;
+ return service;
}
-
+
// getters and setters //////////////////////////////////////////////////////
public long getId() {
return id;
}
+
public ProcessInstance getProcessInstance() {
return processInstance;
}
+
public void setProcessInstance(ProcessInstance processInstance) {
this.processInstance = processInstance;
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/Swimlane.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/Swimlane.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/Swimlane.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -21,27 +21,27 @@
*/
package org.jbpm.taskmgmt.def;
-import java.io.*;
-import java.util.*;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
-import org.jbpm.instantiation.*;
-import org.jbpm.util.EqualsUtil;
+import org.jbpm.instantiation.Delegation;
/**
* is a process role (aka participant).
*/
public class Swimlane implements Serializable {
-
+
private static final long serialVersionUID = 1L;
- long id = 0;
- protected String name = null;
- protected String actorIdExpression = null;
- protected String pooledActorsExpression = null;
- protected Delegation assignmentDelegation = null;
- protected TaskMgmtDefinition taskMgmtDefinition = null;
- protected Set tasks = null;
-
+ long id;
+ protected String name;
+ protected String actorIdExpression;
+ protected String pooledActorsExpression;
+ protected Delegation assignmentDelegation;
+ protected TaskMgmtDefinition taskMgmtDefinition;
+ protected Set tasks;
+
public Swimlane() {
}
@@ -50,8 +50,8 @@
}
/**
- * sets the taskMgmtDefinition unidirectionally. use TaskMgmtDefinition.addSwimlane to create
- * a bidirectional relation.
+ * sets the taskMgmtDefinition unidirectionally. use
+ * TaskMgmtDefinition.addSwimlane to create a bidirectional relation.
*/
public void setTaskMgmtDefinition(TaskMgmtDefinition taskMgmtDefinition) {
this.taskMgmtDefinition = taskMgmtDefinition;
@@ -59,8 +59,8 @@
// tasks ////////////////////////////////////////////////////////////////////
- public void addTask( Task task ) {
- if (tasks==null) tasks = new HashSet();
+ public void addTask(Task task) {
+ if (tasks == null) tasks = new HashSet();
tasks.add(task);
task.setSwimlane(this);
}
@@ -70,24 +70,38 @@
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof Swimlane)) return false;
+
+ Swimlane other = (Swimlane) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return name.equals(other.getName())
+ && taskMgmtDefinition.equals(other.getTaskMgmtDefinition());
}
+ public int hashCode() {
+ int result = 1154431951 + name.hashCode();
+ result = 1436943863 * result + taskMgmtDefinition.hashCode();
+ return result;
+ }
+
public void setActorIdExpression(String actorIdExpression) {
this.actorIdExpression = actorIdExpression;
- // Note: combination of actorIdExpression and pooledActorsExpression is allowed
+ // combination of actorIdExpression and pooledActorsExpression is allowed
// this.pooledActorsExpression = null;
this.assignmentDelegation = null;
}
+
public void setPooledActorsExpression(String pooledActorsExpression) {
- // Note: combination of actorIdExpression and pooledActorsExpression is allowed
+ // combination of actorIdExpression and pooledActorsExpression is allowed
// this.actorIdExpression = null;
this.pooledActorsExpression = pooledActorsExpression;
this.assignmentDelegation = null;
}
+
public void setAssignmentDelegation(Delegation assignmentDelegation) {
// assignment expressions and assignmentDelegation are mutually exclusive
this.actorIdExpression = null;
@@ -100,18 +114,23 @@
public TaskMgmtDefinition getTaskMgmtDefinition() {
return taskMgmtDefinition;
}
+
public String getActorIdExpression() {
return actorIdExpression;
}
+
public String getPooledActorsExpression() {
return pooledActorsExpression;
}
+
public Delegation getAssignmentDelegation() {
return assignmentDelegation;
}
+
public String getName() {
return name;
}
+
public long getId() {
return id;
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/TaskController.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/TaskController.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/def/TaskController.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -36,18 +36,17 @@
import org.jbpm.instantiation.UserCodeInterceptor;
import org.jbpm.instantiation.UserCodeInterceptorConfig;
import org.jbpm.taskmgmt.exe.TaskInstance;
-import org.jbpm.util.EqualsUtil;
/**
* is a controller for one task. this object either delegates to a custom
- * {@link org.jbpm.taskmgmt.def.TaskControllerHandler} or it is configured
- * with {@link org.jbpm.context.def.VariableAccess}s to perform the default
- * behaviour of the controller functionality for a task.
+ * {@link org.jbpm.taskmgmt.def.TaskControllerHandler} or it is configured with
+ * {@link org.jbpm.context.def.VariableAccess}s to perform the default behaviour
+ * of the controller functionality for a task.
*/
public class TaskController implements Serializable {
private static final long serialVersionUID = 1L;
-
+
long id = 0;
/**
@@ -62,35 +61,45 @@
* maps process variable names (java.lang.String) to VariableAccess objects.
*/
List variableAccesses = null;
-
+
public TaskController() {
}
-
+
/**
- * extract the list of information from the process variables and make them available locally.
- * Note that if no task instance variables are specified, the full process variables scope will be
- * visible (that means that the user did not specify a special task instance scope).
+ * extract the list of information from the process variables and make them
+ * available locally. Note that if no task instance variables are specified,
+ * the full process variables scope will be visible (that means that the user
+ * did not specify a special task instance scope).
*/
public void initializeVariables(TaskInstance taskInstance) {
- ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader();
+ ClassLoader surroundingClassLoader = Thread.currentThread()
+ .getContextClassLoader();
try {
- // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448)
- Thread.currentThread().setContextClassLoader(JbpmConfiguration.getProcessClassLoader(taskInstance.getTask().getProcessDefinition()));
+ // set context class loader correctly for delegation class
+ // https://jira.jboss.org/jira/browse/JBPM-1448
+ ClassLoader classLoader = JbpmConfiguration.getProcessClassLoader(taskInstance.getTask()
+ .getProcessDefinition());
+ Thread.currentThread().setContextClassLoader(classLoader);
if (taskControllerDelegation != null) {
TaskControllerHandler taskControllerHandler = (TaskControllerHandler) taskControllerDelegation.instantiate();
- ProcessInstance processInstance = taskInstance.getTaskMgmtInstance().getProcessInstance();
- ContextInstance contextInstance = (processInstance != null ? processInstance.getContextInstance() : null);
+ ProcessInstance processInstance = taskInstance.getTaskMgmtInstance()
+ .getProcessInstance();
+ ContextInstance contextInstance = (processInstance != null ? processInstance.getContextInstance()
+ : null);
Token token = taskInstance.getToken();
UserCodeInterceptor userCodeInterceptor = UserCodeInterceptorConfig.getUserCodeInterceptor();
if (userCodeInterceptor != null) {
- userCodeInterceptor.executeTaskControllerInitialization(taskControllerHandler, taskInstance, contextInstance, token);
- } else {
- taskControllerHandler.initializeTaskVariables(taskInstance, contextInstance, token);
+ userCodeInterceptor.executeTaskControllerInitialization(
+ taskControllerHandler, taskInstance, contextInstance, token);
}
-
- } else {
+ else {
+ taskControllerHandler.initializeTaskVariables(taskInstance,
+ contextInstance, token);
+ }
+ }
+ else {
Token token = taskInstance.getToken();
ProcessInstance processInstance = token.getProcessInstance();
ContextInstance contextInstance = processInstance.getContextInstance();
@@ -103,108 +112,131 @@
if (variableAccess.isReadable()) {
String variableName = variableAccess.getVariableName();
Object value = contextInstance.getVariable(variableName, token);
- log.debug("creating task instance variable '" + mappedName + "' from process variable '" + variableName + "', value '" + value + "'");
+ log.debug("creating task instance variable '" + mappedName
+ + "' from process variable '" + variableName + "', value '"
+ + value + "'");
taskInstance.setVariableLocally(mappedName, value);
- } else {
- log.debug("creating task instance local variable '" + mappedName + "'. initializing with null value.");
+ }
+ else {
+ log.debug("creating task instance local variable '" + mappedName
+ + "'. initializing with null value.");
taskInstance.setVariableLocally(mappedName, null);
}
}
}
}
- } finally {
+ }
+ finally {
Thread.currentThread().setContextClassLoader(surroundingClassLoader);
- }
+ }
}
/**
- * update the process variables from the the task-instance variables.
+ * update the process variables from the the task-instance variables.
*/
public void submitParameters(TaskInstance taskInstance) {
- ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader();
+ ClassLoader surroundingClassLoader = Thread.currentThread()
+ .getContextClassLoader();
try {
- // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448)
- Thread.currentThread().setContextClassLoader(JbpmConfiguration.getProcessClassLoader(taskInstance.getTask().getProcessDefinition()));
+ // set context class loader correctly for delegation class
+ // https://jira.jboss.org/jira/browse/JBPM-1448
+ ClassLoader classLoader = JbpmConfiguration.getProcessClassLoader(taskInstance.getTask()
+ .getProcessDefinition());
+ Thread.currentThread().setContextClassLoader(classLoader);
if (taskControllerDelegation != null) {
TaskControllerHandler taskControllerHandler = (TaskControllerHandler) taskControllerDelegation.instantiate();
- ProcessInstance processInstance = taskInstance.getTaskMgmtInstance().getProcessInstance();
- ContextInstance contextInstance = (processInstance != null ? processInstance.getContextInstance() : null);
+ ProcessInstance processInstance = taskInstance.getTaskMgmtInstance()
+ .getProcessInstance();
+ ContextInstance contextInstance = processInstance != null ? processInstance.getContextInstance()
+ : null;
Token token = taskInstance.getToken();
UserCodeInterceptor userCodeInterceptor = UserCodeInterceptorConfig.getUserCodeInterceptor();
if (userCodeInterceptor != null) {
- userCodeInterceptor.executeTaskControllerSubmission(taskControllerHandler, taskInstance, contextInstance, token);
- } else {
- taskControllerHandler.submitTaskVariables(taskInstance, contextInstance, token);
+ userCodeInterceptor.executeTaskControllerSubmission(
+ taskControllerHandler, taskInstance, contextInstance, token);
}
-
- } else {
-
+ else {
+ taskControllerHandler.submitTaskVariables(taskInstance,
+ contextInstance, token);
+ }
+ }
+ else {
Token token = taskInstance.getToken();
ProcessInstance processInstance = token.getProcessInstance();
ContextInstance contextInstance = processInstance.getContextInstance();
if (variableAccesses != null) {
String missingTaskVariables = null;
- Iterator iter = variableAccesses.iterator();
- while (iter.hasNext()) {
+ for (Iterator iter = variableAccesses.iterator(); iter.hasNext();) {
VariableAccess variableAccess = (VariableAccess) iter.next();
String mappedName = variableAccess.getMappedName();
// first check if the required variableInstances are present
- if ((variableAccess.isRequired()) && (!taskInstance.hasVariableLocally(mappedName))) {
+ if (variableAccess.isRequired()
+ && !taskInstance.hasVariableLocally(mappedName)) {
if (missingTaskVariables == null) {
missingTaskVariables = mappedName;
- } else {
+ }
+ else {
missingTaskVariables += ", " + mappedName;
}
}
}
- // if there are missing, required parameters, throw an
- // IllegalArgumentException
+ // if there are missing, required parameters, puke
if (missingTaskVariables != null) {
- throw new IllegalArgumentException("missing task variables: " + missingTaskVariables);
+ throw new IllegalArgumentException("missing task variables: "
+ + missingTaskVariables);
}
- iter = variableAccesses.iterator();
- while (iter.hasNext()) {
+ for (Iterator iter = variableAccesses.iterator(); iter.hasNext();) {
VariableAccess variableAccess = (VariableAccess) iter.next();
String mappedName = variableAccess.getMappedName();
String variableName = variableAccess.getVariableName();
if (variableAccess.isWritable()) {
Object value = taskInstance.getVariable(mappedName);
if (value != null) {
- log.debug("submitting task variable '" + mappedName + "' to process variable '" + variableName + "', value '" + value + "'");
+ log.debug("submitting task variable '" + mappedName
+ + "' to process variable '" + variableName + "', value '"
+ + value + "'");
contextInstance.setVariable(variableName, value, token);
}
}
}
}
}
- } finally {
+ }
+ finally {
Thread.currentThread().setContextClassLoader(surroundingClassLoader);
}
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof TaskController)) return false;
+
+ // task controller has no notion of equality beyond identity
+ TaskController other = (TaskController) o;
+ return id != 0 && id == other.getId();
}
-
+
// getters and setters //////////////////////////////////////////////////////
public List getVariableAccesses() {
return variableAccesses;
}
+
public Delegation getTaskControllerDelegation() {
return taskControllerDelegation;
}
+
public void setTaskControllerDelegation(Delegation taskControllerDelegation) {
this.taskControllerDelegation = taskControllerDelegation;
}
+
public long getId() {
return id;
}
@@ -212,6 +244,6 @@
public void setVariableAccesses(List variableAccesses) {
this.variableAccesses = variableAccesses;
}
-
+
private static Log log = LogFactory.getLog(TaskController.class);
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/PooledActor.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -26,8 +26,6 @@
import java.util.Iterator;
import java.util.Set;
-import org.jbpm.util.EqualsUtil;
-
public class PooledActor implements Serializable {
private static final long serialVersionUID = 1L;
@@ -38,8 +36,8 @@
protected Set taskInstances = null;
protected SwimlaneInstance swimlaneInstance = null;
- public static Set createPool(String[] actorIds, SwimlaneInstance swimlaneInstance,
- TaskInstance taskInstance) {
+ public static Set createPool(String[] actorIds,
+ SwimlaneInstance swimlaneInstance, TaskInstance taskInstance) {
Set pooledActors = new HashSet();
for (int i = 0; i < actorIds.length; i++) {
PooledActor pooledActor = new PooledActor(actorIds[i]);
@@ -90,14 +88,23 @@
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof PooledActor)) return false;
+
+ PooledActor other = (PooledActor) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return actorId.equals(other.getActorId());
}
+ public int hashCode() {
+ return actorId.hashCode();
+ }
+
public String toString() {
- return "PooledActor(" + actorId + ")";
+ return "PooledActor(" + actorId + ')';
}
// getters and setters //////////////////////////////////////////////////////
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/SwimlaneInstance.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -25,7 +25,6 @@
import java.util.Set;
import org.jbpm.taskmgmt.def.Swimlane;
-import org.jbpm.util.EqualsUtil;
/**
* is a process role for a one process instance.
@@ -34,13 +33,13 @@
private static final long serialVersionUID = 1L;
- long id = 0;
- int version = 0;
- protected String name = null;
- protected String actorId = null;
- protected Set pooledActors = null;
- protected Swimlane swimlane = null;
- protected TaskMgmtInstance taskMgmtInstance = null;
+ long id;
+ int version;
+ protected String name;
+ protected String actorId;
+ protected Set pooledActors;
+ protected Swimlane swimlane;
+ protected TaskMgmtInstance taskMgmtInstance;
public SwimlaneInstance() {
}
@@ -55,12 +54,24 @@
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof SwimlaneInstance)) return false;
+
+ SwimlaneInstance other = (SwimlaneInstance) o;
+ if (id != 0 && id == other.getId()) return true;
+
+ return name.equals(other.getName())
+ && taskMgmtInstance.equals(other.getTaskMgmtInstance());
}
+ public int hashCode() {
+ int result = 1429026763 + name.hashCode();
+ result = 686197649 * result + taskMgmtInstance.hashCode();
+ return result;
+ }
+
// getters and setters //////////////////////////////////////////////////////
public long getId() {
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskInstance.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -50,13 +50,14 @@
import org.jbpm.taskmgmt.log.TaskAssignLog;
import org.jbpm.taskmgmt.log.TaskEndLog;
import org.jbpm.util.Clock;
-import org.jbpm.util.EqualsUtil;
/**
- * is one task instance that can be assigned to an actor (read: put in someone's task list) and
- * that can trigger the continuation of execution of the token upon completion.
+ * is one task instance that can be assigned to an actor (read: put in someone's
+ * task list) and that can trigger the continuation of execution of the token
+ * upon completion.
*/
-public class TaskInstance extends VariableContainer implements Identifiable, Assignable {
+public class TaskInstance extends VariableContainer implements Identifiable,
+ Assignable {
private static final long serialVersionUID = 1L;
@@ -83,7 +84,7 @@
protected Set pooledActors;
protected List comments;
- // not persisted. just extra information for listeners of the task-assign event
+ // not persisted. extra information for task-assign event listeners
protected String previousActorId;
public TaskInstance() {
@@ -108,31 +109,34 @@
}
void submitVariables() {
- TaskController taskController = (task != null ? task.getTaskController() : null);
- // if there is a task controller,
+ TaskController taskController = task != null ? task.getTaskController()
+ : null;
+ // if a task controller is present,
if (taskController != null) {
- // the task controller is responsible for copying variables back into the process
+ // the task controller copies variables back into the process
taskController.submitParameters(this);
}
- // if there is no task controller
+ // in absence of a task controller,
else if (token != null && token.getProcessInstance() != null) {
- // the default behaviour is that all task-local variables are flushed to the process
+ // all task-local variables are flushed to the process
if (variableInstances != null) {
- ContextInstance contextInstance = token.getProcessInstance().getContextInstance();
- Iterator iter = variableInstances.values().iterator();
- while (iter.hasNext()) {
+ ContextInstance contextInstance = token.getProcessInstance()
+ .getContextInstance();
+ for (Iterator iter = variableInstances.values().iterator(); iter.hasNext();) {
VariableInstance variableInstance = (VariableInstance) iter.next();
- log.debug("flushing variable '" + variableInstance.getName() + "' from task '" + name
- + "' to process variables");
- // this was the simplest way to clone the variable instance; might be optimized
- contextInstance.setVariable(variableInstance.getName(), variableInstance.getValue(), token);
+ log.debug("flushing variable '" + variableInstance.getName()
+ + "' from task '" + name + "' to process variables");
+ // simple way to clone the variable instance; might be optimized
+ contextInstance.setVariable(variableInstance.getName(),
+ variableInstance.getValue(), token);
}
}
}
}
void initializeVariables() {
- TaskController taskController = (task != null ? task.getTaskController() : null);
+ TaskController taskController = task != null ? task.getTaskController()
+ : null;
if (taskController != null) {
taskController.initializeVariables(this);
}
@@ -144,12 +148,12 @@
public void create(ExecutionContext executionContext) {
if (create != null) {
- throw new IllegalStateException("task instance '" + id + "' was already created");
+ throw new IllegalStateException(this + " was already created");
}
create = Clock.getCurrentTime();
// if this task instance is associated with a task...
- if ((task != null) && (executionContext != null)) {
+ if (task != null && executionContext != null) {
// the TASK_CREATE event is fired
executionContext.setTaskInstance(this);
executionContext.setTask(task);
@@ -177,14 +181,17 @@
}
else { // lazily initialize the swimlane...
// get the swimlane instance (if there is any)
- swimlaneInstance = taskMgmtInstance.getInitializedSwimlaneInstance(executionContext, swimlane);
+ swimlaneInstance = taskMgmtInstance.getInitializedSwimlaneInstance(
+ executionContext, swimlane);
// copy the swimlaneInstance assignment into the taskInstance assignment
copySwimlaneInstanceAssignment(swimlaneInstance);
}
}
else { // this task is not in a swimlane
- taskMgmtInstance.performAssignment(task.getAssignmentDelegation(), task.getActorIdExpression(), task.getPooledActorsExpression(), this, executionContext);
+ taskMgmtInstance.performAssignment(task.getAssignmentDelegation(),
+ task.getActorIdExpression(), task.getPooledActorsExpression(), this,
+ executionContext);
}
updatePooledActorsReferences(swimlaneInstance);
@@ -192,17 +199,17 @@
public boolean isStartTaskInstance() {
boolean isStartTaskInstance = false;
- if (taskMgmtInstance != null && taskMgmtInstance.getTaskMgmtDefinition() != null) {
+ if (taskMgmtInstance != null
+ && taskMgmtInstance.getTaskMgmtDefinition() != null) {
isStartTaskInstance = task != null
- && task.equals(taskMgmtInstance.getTaskMgmtDefinition().getStartTask());
+ && task.equals(taskMgmtInstance.getTaskMgmtDefinition().getStartTask());
}
return isStartTaskInstance;
}
void updatePooledActorsReferences(SwimlaneInstance swimlaneInstance) {
if (pooledActors != null) {
- Iterator iter = pooledActors.iterator();
- while (iter.hasNext()) {
+ for (Iterator iter = pooledActors.iterator(); iter.hasNext();) {
PooledActor pooledActor = (PooledActor) iter.next();
pooledActor.setSwimlaneInstance(swimlaneInstance);
pooledActor.addTaskInstance(this);
@@ -211,8 +218,8 @@
}
/**
- * copies the assignment (that includes both the swimlaneActorId and the set of pooledActors)
- * of the given swimlane into this taskInstance.
+ * copies the assignment (that includes both the swimlaneActorId and the set
+ * of pooledActors) of the given swimlane into this taskInstance.
*/
public void copySwimlaneInstanceAssignment(SwimlaneInstance swimlaneInstance) {
setSwimlaneInstance(swimlaneInstance);
@@ -221,19 +228,21 @@
}
/**
- * gets the pool of actors for this task instance. If this task has a simlaneInstance and no
- * pooled actors, the pooled actors of the swimlane instance are returned.
+ * gets the pool of actors for this task instance. If this task has a
+ * simlaneInstance and no pooled actors, the pooled actors of the swimlane
+ * instance are returned.
*/
public Set getPooledActors() {
- if (swimlaneInstance != null && (pooledActors == null || pooledActors.isEmpty())) {
+ if (swimlaneInstance != null
+ && (pooledActors == null || pooledActors.isEmpty())) {
return swimlaneInstance.getPooledActors();
}
return pooledActors;
}
/**
- * (re)assign this task to the given actor. If this task is related to a swimlane instance,
- * that swimlane instance will be updated as well.
+ * (re)assign this task to the given actor. If this task is related to a
+ * swimlane instance, that swimlane instance will be updated as well.
*/
public void setActorId(String actorId) {
setActorId(actorId, true);
@@ -243,20 +252,20 @@
* (re)assign this task to the given actor.
*
* @param actorId is reference to the person that is assigned to this task.
- * @param overwriteSwimlane specifies if the related swimlane should be overwritten with the
- * given swimlaneActorId.
+ * @param overwriteSwimlane specifies if the related swimlane should be
+ * overwritten with the given swimlaneActorId.
*/
public void setActorId(String actorId, boolean overwriteSwimlane) {
// do the actual assignment
this.previousActorId = this.actorId;
this.actorId = actorId;
- if ((swimlaneInstance != null) && (overwriteSwimlane)) {
+ if (swimlaneInstance != null && overwriteSwimlane) {
log.debug("assigning task '" + name + "' to '" + actorId + "'");
swimlaneInstance.setActorId(actorId);
}
// fire the event
- if ((task != null) && (token != null)) {
+ if (task != null && token != null) {
ExecutionContext executionContext = new ExecutionContext(token);
executionContext.setTask(task);
executionContext.setTaskInstance(this);
@@ -280,12 +289,12 @@
}
/**
- * can optionally be used to indicate that the actor is starting to work on this task
- * instance.
+ * can optionally be used to indicate that the actor is starting to work on
+ * this task instance.
*/
public void start() {
if (start != null) {
- throw new IllegalStateException("task instance '" + id + "' is already started");
+ throw new IllegalStateException(this + " is already started");
}
start = Clock.getCurrentTime();
@@ -298,15 +307,16 @@
}
/**
- * convenience method that combines a {@link #setActorId(String)} and a {@link #start()}.
+ * convenience method that combines a {@link #setActorId(String)} and a
+ * {@link #start()}.
*/
public void start(String actorId) {
start(actorId, true);
}
/**
- * convenience method that combines a {@link #setActorId(String,boolean)} and a
- * {@link #start()}.
+ * convenience method that combines a {@link #setActorId(String,boolean)} and
+ * a {@link #start()}.
*/
public void start(String actorId, boolean overwriteSwimlane) {
setActorId(actorId, overwriteSwimlane);
@@ -326,8 +336,9 @@
}
/**
- * cancels this task. This task instance will be marked as cancelled and as ended. But
- * cancellation doesn't influence signalling and continuation of process execution.
+ * cancels this task. This task instance will be marked as cancelled and as
+ * ended. But cancellation doesn't influence signalling and continuation of
+ * process execution.
*/
public void cancel() {
markAsCancelled();
@@ -335,9 +346,9 @@
}
/**
- * cancels this task, takes the specified transition. This task intance will be marked as
- * cancelled and as ended. But cancellation doesn't influence singalling and continuation of
- * process execution.
+ * cancels this task, takes the specified transition. This task intance will
+ * be marked as cancelled and as ended. But cancellation doesn't influence
+ * singalling and continuation of process execution.
*/
public void cancel(Transition transition) {
markAsCancelled();
@@ -345,9 +356,9 @@
}
/**
- * cancels this task, takes the specified transition. This task intance will be marked as
- * cancelled and as ended. But cancellation doesn't influence singalling and continuation of
- * process execution.
+ * cancels this task, takes the specified transition. This task intance will
+ * be marked as cancelled and as ended. But cancellation doesn't influence
+ * singalling and continuation of process execution.
*/
public void cancel(String transitionName) {
markAsCancelled();
@@ -355,8 +366,8 @@
}
/**
- * marks this task as done. If this task is related to a task node this might trigger a signal
- * on the token.
+ * marks this task as done. If this task is related to a task node this might
+ * trigger a signal on the token.
*
* @see #end(Transition)
*/
@@ -365,43 +376,46 @@
}
/**
- * marks this task as done and specifies the name of a transition leaving the task-node for
- * the case that the completion of this task instances triggers a signal on the token. If this
- * task leads to a signal on the token, the given transition name will be used in the signal.
- * If this task completion does not trigger execution to move on, the transitionName is
- * ignored.
+ * marks this task as done and specifies the name of a transition leaving the
+ * task-node for the case that the completion of this task instances triggers
+ * a signal on the token. If this task leads to a signal on the token, the
+ * given transition name will be used in the signal. If this task completion
+ * does not trigger execution to move on, the transitionName is ignored.
*/
public void end(String transitionName) {
- Transition leavingTransition = null;
+ if (task == null) {
+ throw new JbpmException(this + " has no task definition");
+ }
- if (task != null) {
- Node node = task.getTaskNode();
+ Node node = task.getTaskNode();
+ if (node == null) {
+ node = (Node) task.getParent();
if (node == null) {
- node = (Node) task.getParent();
+ throw new JbpmException(this + " has no enclosing node");
}
+ }
- if (node != null) {
- leavingTransition = node.getLeavingTransition(transitionName);
- }
- }
+ Transition leavingTransition = node.getLeavingTransition(transitionName);
if (leavingTransition == null) {
- throw new JbpmException("task node does not have leaving transition: " + transitionName);
+ throw new JbpmException(node + " has no leaving transition named "
+ + transitionName);
}
end(leavingTransition);
}
/**
- * marks this task as done and specifies a transition leaving the task-node for the case that
- * the completion of this task instances triggers a signal on the token. If this task leads to
- * a signal on the token, the given transition name will be used in the signal. If this task
- * completion does not trigger execution to move on, the transition is ignored.
+ * marks this task as done and specifies a transition leaving the task-node
+ * for the case that the completion of this task instances triggers a signal
+ * on the token. If this task leads to a signal on the token, the given
+ * transition name will be used in the signal. If this task completion does
+ * not trigger execution to move on, the transition is ignored.
*/
public void end(Transition transition) {
if (this.end != null) {
- throw new IllegalStateException("task instance '" + id + "' is already ended");
+ throw new IllegalStateException(this + " has ended");
}
if (this.isSuspended) {
- throw new JbpmException("task instance '" + id + "' is suspended");
+ throw new JbpmException(this + " is suspended");
}
// mark the end of this task instance
@@ -424,22 +438,22 @@
// submit the variables
submitVariables();
- // verify if the end of this task triggers continuation of execution
+ // check whether completing this task causes execution to proceed
if (isSignalling) {
this.isSignalling = false;
- if (this.isStartTaskInstance() // ending start tasks always leads to a signal
- || (task != null && token != null && task.getTaskNode() != null && task.getTaskNode()
- .completionTriggersSignal(this))) {
+ if (this.isStartTaskInstance() // ending start task leads to signal
+ || (task != null && token != null && task.getTaskNode() != null && task.getTaskNode()
+ .completionTriggersSignal(this))) {
if (transition == null) {
- log.debug("completion of task '" + task.getName()
- + "' results in taking the default transition");
+ log.debug("completion of " + task
+ + " results in taking the default transition");
token.signal();
}
else {
- log.debug("completion of task '" + task.getName()
- + "' results in taking transition '" + transition + "'");
+ log.debug("completion of " + task.getName() + " results in taking "
+ + transition);
token.signal(transition);
}
}
@@ -455,7 +469,7 @@
*/
public void suspend() {
if (!isOpen) {
- throw new JbpmException("a task that is not open cannot be suspended: " + toString());
+ throw new JbpmException("task is not open");
}
isSuspended = true;
}
@@ -465,7 +479,7 @@
*/
public void resume() {
if (!isOpen) {
- throw new JbpmException("a task that is not open cannot be resumed: " + toString());
+ throw new JbpmException("task is not open");
}
isSuspended = false;
}
@@ -499,27 +513,33 @@
}
/**
- * is the list of transitions that can be used in the end method and it is null in case this
- * is not the last task instance.
+ * is the list of transitions that can be used in the end method and it is
+ * null in case this is not the last task instance.
*/
public List getAvailableTransitions() {
List transitions = null;
- if ((!isLast()) && (token != null)) {
+ if (!isLast() && token != null) {
transitions = new ArrayList(token.getAvailableTransitions());
}
return transitions;
}
// equals ///////////////////////////////////////////////////////////////////
- // hack to support comparing hibernate proxies against the real objects
- // since this always falls back to ==, we don't need to overwrite the hashcode
+
public boolean equals(Object o) {
- return EqualsUtil.equals(this, o);
+ if (this == o) return true;
+ if (!(o instanceof TaskInstance)) return false;
+
+ // task instance has no notion of equality other than identity
+ // see Wfp15MiWithAPrioriRuntimeKnowledgeTest
+ TaskInstance other = (TaskInstance) o;
+ return id != 0 && id == other.getId();
}
public String toString() {
return "TaskInstance"
- + (name != null ? "(" + name + ")" : "@" + Integer.toHexString(hashCode()));
+ + (name != null ? '(' + name + ')' : id != 0 ? "(" + id + ')'
+ : '@' + Integer.toHexString(hashCode()));
}
// private //////////////////////////////////////////////////////////////////
@@ -528,8 +548,7 @@
public void setPooledActors(Set pooledActors) {
if (pooledActors != null) {
this.pooledActors = new HashSet(pooledActors);
- Iterator iter = pooledActors.iterator();
- while (iter.hasNext()) {
+ for (Iterator iter = pooledActors.iterator(); iter.hasNext();) {
PooledActor pooledActor = (PooledActor) iter.next();
pooledActor.addTaskInstance(this);
}
@@ -543,7 +562,8 @@
protected VariableContainer getParentVariableContainer() {
ContextInstance contextInstance = getContextInstance();
- return (contextInstance != null ? contextInstance.getOrCreateTokenVariableMap(token) : null);
+ return contextInstance != null ? contextInstance.getOrCreateTokenVariableMap(token)
+ : null;
}
// getters and setters //////////////////////////////////////////////////////
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/taskmgmt/exe/TaskMgmtInstance.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -63,14 +63,12 @@
private static final long serialVersionUID = 1L;
- TaskMgmtDefinition taskMgmtDefinition = null;
- Map swimlaneInstances = null;
- Set taskInstances = null;
+ TaskMgmtDefinition taskMgmtDefinition;
+ Map swimlaneInstances;
+ Set taskInstances;
- /**
- * non persistent collection that stores all the task instances that have variable updates
- */
- Collection taskInstanceVariableUpdates = null;
+ /** stores task instances having variable updates. not persisted. */
+ Collection taskInstanceVariableUpdates;
public TaskMgmtInstance() {
}
@@ -94,7 +92,7 @@
}
/**
- * creates a new task instance on the given token, for the given task.
+ * creates an instance of the given task, for the given token.
*/
public TaskInstance createTaskInstance(Task task, Token token) {
ExecutionContext executionContext = new ExecutionContext(token);
@@ -103,18 +101,19 @@
}
/**
- * creates a new task instance on the given task, in the given execution context.
+ * creates an instance of the given task, in the given execution context.
*/
- public TaskInstance createTaskInstance(Task task, ExecutionContext executionContext) {
+ public TaskInstance createTaskInstance(Task task,
+ ExecutionContext executionContext) {
// instantiate the new task instance
TaskInstance taskInstance = instantiateNewTaskInstance(executionContext);
- // bind the task instance to the TaskMgmtInstance
- addTaskInstance(taskInstance);
-
// initialize the task instance
if (task != null) taskInstance.setTask(task);
+ // bind the task instance to the TaskMgmtInstance
+ addTaskInstance(taskInstance);
+
// assign an id to the task instance
Services.assignId(taskInstance);
@@ -131,8 +130,10 @@
String durationString = null;
if (dueDateString.startsWith("#")) {
- String baseDateEL = dueDateString.substring(0, dueDateString.indexOf("}") + 1);
- Object result = JbpmExpressionEvaluator.evaluate(baseDateEL, executionContext);
+ String baseDateEL = dueDateString.substring(0,
+ dueDateString.indexOf("}") + 1);
+ Object result = JbpmExpressionEvaluator.evaluate(baseDateEL,
+ executionContext);
if (result instanceof Date) {
baseDate = (Date) result;
}
@@ -140,17 +141,15 @@
baseDate = ((Calendar) result).getTime();
}
else {
- throw new JbpmException("Invalid basedate type: "
- + baseDateEL
- + " is of type "
- + result.getClass().getName()
- + ". Only Date and Calendar are supported");
+ throw new JbpmException("base date is neither Date nor Calendar");
}
int endOfELIndex = dueDateString.indexOf("}");
if (endOfELIndex < (dueDateString.length() - 1)) {
- char durationSeparator = dueDateString.substring(endOfELIndex + 1).trim().charAt(0);
+ char durationSeparator = dueDateString.substring(endOfELIndex + 1)
+ .trim()
+ .charAt(0);
if (durationSeparator != '+' && durationSeparator != '-') {
- throw new JbpmException("Invalid duedate, + or - missing after EL");
+ throw new JbpmException("'+' or '-' missing after expression");
}
durationString = dueDateString.substring(endOfELIndex + 1).trim();
}
@@ -180,7 +179,8 @@
if (task != null) {
String description = task.getDescription();
if ((description != null) && (description.indexOf("#{") != -1)) {
- Object result = JbpmExpressionEvaluator.evaluate(description, executionContext);
+ Object result = JbpmExpressionEvaluator.evaluate(description,
+ executionContext);
if (result != null) {
taskInstance.setDescription(result.toString());
}
@@ -213,8 +213,8 @@
return taskInstance;
}
- public SwimlaneInstance getInitializedSwimlaneInstance(ExecutionContext executionContext,
- Swimlane swimlane) {
+ public SwimlaneInstance getInitializedSwimlaneInstance(
+ ExecutionContext executionContext, Swimlane swimlane) {
// initialize the swimlane
if (swimlaneInstances == null) swimlaneInstances = new HashMap();
SwimlaneInstance swimlaneInstance = (SwimlaneInstance) swimlaneInstances.get(swimlane.getName());
@@ -222,28 +222,33 @@
swimlaneInstance = new SwimlaneInstance(swimlane);
addSwimlaneInstance(swimlaneInstance);
// assign the swimlaneInstance
- performAssignment(swimlane.getAssignmentDelegation(), swimlane.getActorIdExpression(),
- swimlane.getPooledActorsExpression(), swimlaneInstance, executionContext);
+ performAssignment(swimlane.getAssignmentDelegation(),
+ swimlane.getActorIdExpression(),
+ swimlane.getPooledActorsExpression(), swimlaneInstance,
+ executionContext);
}
return swimlaneInstance;
}
- public void performAssignment(Delegation assignmentDelegation, String actorIdExpression,
- String pooledActorsExpression, Assignable assignable, ExecutionContext executionContext) {
+ public void performAssignment(Delegation assignmentDelegation,
+ String actorIdExpression, String pooledActorsExpression,
+ Assignable assignable, ExecutionContext executionContext) {
try {
if (assignmentDelegation != null) {
- performAssignmentDelegation(assignmentDelegation, assignable, executionContext);
+ performAssignmentDelegation(assignmentDelegation, assignable,
+ executionContext);
}
else {
if (actorIdExpression != null) {
- performAssignmentActorIdExpr(actorIdExpression, assignable, executionContext);
+ performAssignmentActorIdExpr(actorIdExpression, assignable,
+ executionContext);
}
if (pooledActorsExpression != null) {
- performAssignmentPooledActorsExpr(pooledActorsExpression, assignable, executionContext);
+ performAssignmentPooledActorsExpr(pooledActorsExpression, assignable,
+ executionContext);
}
}
-
}
catch (Exception exception) {
GraphElement graphElement = executionContext.getEventSource();
@@ -256,20 +261,24 @@
}
}
- void performAssignmentDelegation(Delegation assignmentDelegation, Assignable assignable,
- ExecutionContext executionContext) throws Exception {
- ClassLoader surroundingClassLoader = Thread.currentThread().getContextClassLoader();
+ void performAssignmentDelegation(Delegation assignmentDelegation,
+ Assignable assignable, ExecutionContext executionContext)
+ throws Exception {
+ ClassLoader surroundingClassLoader = Thread.currentThread()
+ .getContextClassLoader();
try {
- // set context class loader correctly for delegation class (https://jira.jboss.org/jira/browse/JBPM-1448)
- Thread.currentThread().setContextClassLoader(
- JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition()));
+ // set context class loader correctly for delegation class
+ // https://jira.jboss.org/jira/browse/JBPM-1448
+ ClassLoader processClassLoader = JbpmConfiguration.getProcessClassLoader(executionContext.getProcessDefinition());
+ Thread.currentThread().setContextClassLoader(processClassLoader);
// instantiate the assignment handler
AssignmentHandler assignmentHandler = (AssignmentHandler) assignmentDelegation.instantiate();
// invoke the assignment handler
UserCodeInterceptor userCodeInterceptor = UserCodeInterceptorConfig.getUserCodeInterceptor();
if (userCodeInterceptor != null) {
- userCodeInterceptor.executeAssignment(assignmentHandler, assignable, executionContext);
+ userCodeInterceptor.executeAssignment(assignmentHandler, assignable,
+ executionContext);
}
else {
assignmentHandler.assign(assignable, executionContext);
@@ -280,37 +289,31 @@
}
}
- void performAssignmentActorIdExpr(String actorIdExpression, Assignable assignable,
- ExecutionContext executionContext) {
- Object result = null;
- String actorId = null;
- try {
- result = JbpmExpressionEvaluator.evaluate(actorIdExpression, executionContext);
- if (result == null) {
- throw new JbpmException("actor-id expression '" + actorIdExpression + "' returned null");
- }
- actorId = (String) result;
+ void performAssignmentActorIdExpr(String actorIdExpression,
+ Assignable assignable, ExecutionContext executionContext) {
+ Object result = JbpmExpressionEvaluator.evaluate(actorIdExpression,
+ executionContext);
+ if (result == null) {
+ throw new JbpmException("actor-id expression '" + actorIdExpression
+ + "' returned null");
}
- catch (ClassCastException e) {
- throw new JbpmException("actor-id expression '"
- + actorIdExpression
- + "' didn't resolve to a java.lang.String: '"
- + result
- + "' ("
- + result.getClass().getName()
- + ")");
+ if (result instanceof String) {
+ assignable.setActorId((String) result);
}
- assignable.setActorId(actorId);
+ else {
+ throw new JbpmException("actor-id expression '" + actorIdExpression
+ + "' did not evaluate to string: '" + result);
+ }
}
- void performAssignmentPooledActorsExpr(String pooledActorsExpression, Assignable assignable,
- ExecutionContext executionContext) {
+ void performAssignmentPooledActorsExpr(String pooledActorsExpression,
+ Assignable assignable, ExecutionContext executionContext) {
String[] pooledActors = null;
- Object result = JbpmExpressionEvaluator.evaluate(pooledActorsExpression, executionContext);
+ Object result = JbpmExpressionEvaluator.evaluate(pooledActorsExpression,
+ executionContext);
if (result == null) {
throw new JbpmException("pooled-actors expression '"
- + pooledActorsExpression
- + "' returned null");
+ + pooledActorsExpression + "' returned null");
}
if (result instanceof String[]) {
@@ -329,20 +332,19 @@
pooledActors = (String[]) pooledActorList.toArray(new String[pooledActorList.size()]);
}
else {
- throw new JbpmException("pooled-actors expression '"
- + pooledActorsExpression
- + "' didn't resolve to a comma separated String, a Collection or a String[]: '"
- + result
- + "' ("
- + result.getClass().getName()
- + ")");
+ throw new JbpmException(
+ "pooled-actors expression '"
+ + pooledActorsExpression
+ + "' did not evaluate to comma-separated string, collection or string array: "
+ + result);
}
assignable.setPooledActors(pooledActors);
}
/**
- * creates a task instance on the rootToken, and assigns it to the currently authenticated user.
+ * creates a task instance on the rootToken, and assigns it to the currently
+ * authenticated user.
*/
public TaskInstance createStartTaskInstance() {
TaskInstance taskInstance = null;
@@ -358,24 +360,19 @@
TaskInstance instantiateNewTaskInstance(ExecutionContext executionContext) {
TaskInstanceFactory taskInstanceFactory = (TaskInstanceFactory) JbpmConfiguration.Configs.getObject("jbpm.task.instance.factory");
- if (taskInstanceFactory == null) {
- throw new JbpmException("jbpm.task.instance.factory was not configured in jbpm.cfg.xml");
- }
return taskInstanceFactory.createTaskInstance(executionContext);
}
/**
- * is true if the given token has task instances that keep the token from leaving the current
- * node.
+ * is true if the given token has task instances that keep the token from
+ * leaving the current node.
*/
public boolean hasBlockingTaskInstances(Token token) {
if (taskInstances != null) {
for (Iterator i = taskInstances.iterator(); i.hasNext();) {
TaskInstance taskInstance = (TaskInstance) i.next();
- if (!taskInstance.hasEnded()
- && taskInstance.isBlocking()
- && token != null
- && token.equals(taskInstance.getToken())) {
+ if (!taskInstance.hasEnded() && taskInstance.isBlocking()
+ && token != null && token.equals(taskInstance.getToken())) {
return true;
}
}
@@ -391,7 +388,8 @@
}
/**
- * is the collection of {@link TaskInstance}s on the given token that are not ended.
+ * is the collection of {@link TaskInstance}s on the given token that are not
+ * ended.
*/
public Collection getUnfinishedTasks(Token token) {
Collection unfinishedTasks = new ArrayList();
@@ -407,16 +405,16 @@
}
/**
- * is true if there are {@link TaskInstance}s on the given token that can trigger the token to
- * continue.
+ * is true if there are {@link TaskInstance}s on the given token that can
+ * trigger the token to continue.
*/
public boolean hasSignallingTasks(ExecutionContext executionContext) {
return (getSignallingTasks(executionContext).size() > 0);
}
/**
- * is the collection of {@link TaskInstance}s for the given token that can trigger the token to
- * continue.
+ * is the collection of {@link TaskInstance}s for the given token that can
+ * trigger the token to continue.
*/
public Collection getSignallingTasks(ExecutionContext executionContext) {
Collection signallingTasks = new ArrayList();
@@ -424,7 +422,7 @@
for (Iterator i = taskInstances.iterator(); i.hasNext();) {
TaskInstance taskInstance = (TaskInstance) i.next();
if (taskInstance.isSignalling()
- && (executionContext.getToken().equals(taskInstance.getToken()))) {
+ && (executionContext.getToken().equals(taskInstance.getToken()))) {
signallingTasks.add(taskInstance);
}
}
@@ -433,8 +431,8 @@
}
/**
- * returns all the taskInstances for the this process instance. This includes task instances that
- * have been completed previously.
+ * returns all the taskInstances for the this process instance. This includes
+ * task instances that have been completed previously.
*/
public Collection getTaskInstances() {
return taskInstances;
@@ -475,8 +473,7 @@
if (swimlane != null) {
return createSwimlaneInstance(swimlane);
}
- throw new JbpmException("couldn't create swimlane instance for non-existing swimlane "
- + swimlaneName);
+ throw new JbpmException("swimlane does not exist: " + swimlaneName);
}
public SwimlaneInstance createSwimlaneInstance(Swimlane swimlane) {
@@ -558,7 +555,8 @@
}
/**
- * removes signalling capabilities from all task instances related to the given token.
+ * removes signalling capabilities from all task instances related to the
+ * given token.
*/
public void removeSignalling(Token token) {
if (token != null && taskInstances != null) {
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/ArrayUtil.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -21,100 +21,132 @@
*/
package org.jbpm.util;
+import java.util.List;
+
/**
* Various methods for manipulating arrays.
*/
public class ArrayUtil {
- private ArrayUtil() {
- // hide default constructor to prevent instantiation
- }
+ private ArrayUtil() {
+ // hide default constructor to prevent instantiation
+ }
- /**
- * Returns a string representation of the contents of the specified array. If the array
- * contains other arrays as elements, they are converted to strings by the
- * {@link Object#toString} method inherited from <tt>Object</tt>, which describes their
- * <i>identities</i> rather than their contents.
- * <p>
- * The value returned by this method is equal to the value that would be returned by
- * <tt>Arrays.asList(a).toString()</tt>, unless the array is <tt>null</tt>, in which case
- * <tt>"null"</tt> is returned.
- *
- * @param a the array whose string representation to return
- * @return a string representation of <tt>a</tt>
- * @see <a
- * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html#toString(Object[])">
- * java.util.Arrays.toString(Object[])</a>
- */
- public static String toString(Object[] a) {
- if (a == null) return "null";
- if (a.length == 0) return "[]";
+ /**
+ * Returns a hash code based on the contents of the specified array. For any
+ * two <tt>byte</tt> arrays <tt>a</tt> and <tt>b</tt> such that
+ * <tt>Arrays.equals(a, b)</tt>, it is also the case that
+ * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
+ *
+ * <p>
+ * The value returned by this method is the same value that would be obtained
+ * by invoking the {@link List#hashCode() <tt>hashCode</tt>} method on a
+ * {@link List} containing a sequence of {@link Byte} instances representing
+ * the elements of <tt>a</tt> in the same order. If <tt>a</tt> is
+ * <tt>null</tt>, this method returns 0.
+ *
+ * @param a the array whose hash value to compute
+ * @return a content-based hash code for <tt>a</tt>
+ */
+ public static int hashCode(byte a[]) {
+ if (a == null) {
+ return 0;
+ }
- StringBuffer buf = new StringBuffer();
- buf.append('[').append(a[0]);
+ int result = 1;
+ for (int i = 0; i < a.length; i++) {
+ result = 31 * result + a[i];
+ }
- for (int i = 1; i < a.length; i++) {
- buf.append(", ").append(a[i]);
- }
+ return result;
+ }
- return buf.append(']').toString();
- }
+ /**
+ * Returns a string representation of the contents of the specified array. If
+ * the array contains other arrays as elements, they are converted to strings
+ * by the {@link Object#toString} method inherited from <tt>Object</tt>, which
+ * describes their <i>identities</i> rather than their contents.
+ * <p>
+ * The value returned by this method is equal to the value that would be
+ * returned by <tt>Arrays.asList(a).toString()</tt>, unless the array is
+ * <tt>null</tt>, in which case <tt>"null"</tt> is returned.
+ *
+ * @param a the array whose string representation to return
+ * @return a string representation of <tt>a</tt>
+ * @see <a
+ * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html#toString(Object[])">
+ * java.util.Arrays.toString(Object[])</a>
+ */
+ public static String toString(Object[] a) {
+ if (a == null) return "null";
+ if (a.length == 0) return "[]";
- /**
- * Returns a string representation of the contents of the specified array. The string
- * representation consists of a list of the array's elements, enclosed in square brackets (
- * <tt>"[]"</tt>). Adjacent elements are separated by the characters <tt>", "</tt> (a comma
- * followed by a space). Elements are converted to strings by <tt>String.valueOf(long)</tt>.
- * Returns <tt>"null"</tt> if the array is <tt>null</tt>.
- *
- * @param a the array whose string representation to return
- * @return a string representation of <tt>a</tt>
- * @see <a
- * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html#toString(long[])">
- * java.util.Arrays.toString(long[])</a>
- */
- public static String toString(long[] a) {
- if (a == null) return "null";
- if (a.length == 0) return "[]";
+ StringBuffer buf = new StringBuffer();
+ buf.append('[').append(a[0]);
- StringBuffer buf = new StringBuffer();
- buf.append('[');
- buf.append(a[0]);
+ for (int i = 1; i < a.length; i++) {
+ buf.append(", ").append(a[i]);
+ }
- for (int i = 1; i < a.length; i++) {
- buf.append(", ").append(a[i]);
- }
+ return buf.append(']').toString();
+ }
- return buf.append(']').toString();
- }
+ /**
+ * Returns a string representation of the contents of the specified array. The
+ * string representation consists of a list of the array's elements, enclosed
+ * in square brackets ( <tt>"[]"</tt>). Adjacent elements are separated by the
+ * characters <tt>", "</tt> (a comma followed by a space). Elements are
+ * converted to strings by <tt>String.valueOf(long)</tt>. Returns
+ * <tt>"null"</tt> if the array is <tt>null</tt>.
+ *
+ * @param a the array whose string representation to return
+ * @return a string representation of <tt>a</tt>
+ * @see <a
+ * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Arrays.html#toString(long[])">
+ * java.util.Arrays.toString(long[])</a>
+ */
+ public static String toString(long[] a) {
+ if (a == null) return "null";
+ if (a.length == 0) return "[]";
- /**
- * Returns the index in the given array of the first occurrence of the specified element, or
- * -1 if the array does not contain this element.
- *
- * @param o element to search for.
- * @return the index of the first occurrence of the specified element, or -1 if the array does
- * not contain this element.
- */
- public static int indexOf(Object[] a, Object o) {
- if (o == null) {
- for (int i = 0; i < a.length; i++)
- if (a[i] == null) return i;
- }
- else {
- for (int i = 0; i < a.length; i++)
- if (o.equals(a[i])) return i;
- }
- return -1;
- }
+ StringBuffer buf = new StringBuffer();
+ buf.append('[');
+ buf.append(a[0]);
- /**
- * Tells whether the given array contains the specified element.
- *
- * @param o element whose presence in the array is to be tested.
- * @return <tt>true</tt> if the array contains the specified element.
- */
- public static boolean contains(Object[] a, Object o) {
- return indexOf(a, o) != -1;
- }
+ for (int i = 1; i < a.length; i++) {
+ buf.append(", ").append(a[i]);
+ }
+
+ return buf.append(']').toString();
+ }
+
+ /**
+ * Returns the index in the given array of the first occurrence of the
+ * specified element, or -1 if the array does not contain this element.
+ *
+ * @param o element to search for.
+ * @return the index of the first occurrence of the specified element, or -1
+ * if the array does not contain this element.
+ */
+ public static int indexOf(Object[] a, Object o) {
+ if (o == null) {
+ for (int i = 0; i < a.length; i++)
+ if (a[i] == null) return i;
+ }
+ else {
+ for (int i = 0; i < a.length; i++)
+ if (o.equals(a[i])) return i;
+ }
+ return -1;
+ }
+
+ /**
+ * Tells whether the given array contains the specified element.
+ *
+ * @param o element whose presence in the array is to be tested.
+ * @return <tt>true</tt> if the array contains the specified element.
+ */
+ public static boolean contains(Object[] a, Object o) {
+ return indexOf(a, o) != -1;
+ }
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/EqualsUtil.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/EqualsUtil.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/main/java/org/jbpm/util/EqualsUtil.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -29,6 +29,12 @@
// hide default constructor to prevent instantiation
}
+ /**
+ * hack to support comparing hibernate proxies against the real objects.
+ * since it falls back to ==, clients don't need to override hashcode.
+ * @deprecated hack does not work
+ * @see <a href="https://jira.jboss.org/jira/browse/JBPM-2489f">JBPM-2489</a>
+ */
public static boolean equals(Object thisObject, Object otherObject) {
return thisObject == otherObject || otherObject instanceof HibernateProxy
&& otherObject.equals(thisObject);
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/ProcessInstanceCommandTest.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -15,145 +15,146 @@
*/
public class ProcessInstanceCommandTest extends AbstractDbTestCase {
- private ProcessDefinition processDefinition;
-
- protected void tearDown() throws Exception {
- if (processDefinition != null) {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
- }
- processDefinition = null;
-
- super.tearDown();
- }
-
public void testCancelProcessInstanceCommand() throws Exception {
String xml = "<process-definition name='TestException'>"
- + " <start-state name='start'>"
- + " <transition to='fork' />"
- + " </start-state>"
- + " <fork name='fork'>"
- + " <transition name='path1' to='path1' />"
- + " <transition name='path2' to='path2' />"
- + " </fork>"
- + " <state name='path1'>"
- + " <transition to='join' />"
- + " </state>"
- + " <state name='path2'>"
- + " <transition to='join' />"
- + " </state>"
- + " <join name='join'>"
- + " <transition to='end' />"
- + " </join>"
- + " <end-state name='end' />"
- + "</process-definition>";
-
- processDefinition = ProcessDefinition.parseXmlString(xml);
+ + " <start-state name='start'>"
+ + " <transition to='fork' />"
+ + " </start-state>"
+ + " <fork name='fork'>"
+ + " <transition name='path1' to='path1' />"
+ + " <transition name='path2' to='path2' />"
+ + " </fork>"
+ + " <state name='path1'>"
+ + " <transition to='join' />"
+ + " </state>"
+ + " <state name='path2'>"
+ + " <transition to='join' />"
+ + " </state>"
+ + " <join name='join'>"
+ + " <transition to='end' />"
+ + " </join>"
+ + " <end-state name='end' />"
+ + "</process-definition>";
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(xml);
jbpmContext.deployProcessDefinition(processDefinition);
- ProcessInstance processInstance = processDefinition.createProcessInstance();
- processInstance.getRootToken().signal();
- processInstance = saveAndReload(processInstance);
- assertFalse(processInstance.getRootToken().hasEnded());
- assertEquals("fork", processInstance.getRootToken().getNode().getName());
- for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) {
- Token childToken = (Token) iterator.next();
- assertFalse(childToken.hasEnded());
- }
+ newTransaction();
+ try {
+ ProcessInstance processInstance = processDefinition.createProcessInstance();
+ processInstance.signal();
- // execute CancelProcessInstanceCommand
- new CancelProcessInstanceCommand(processInstance.getId()).execute(jbpmContext);
+ processInstance = saveAndReload(processInstance);
+ assert !processInstance.hasEnded() : processInstance;
- // and verify it is canceled
- assertTrue(processInstance.getRootToken().hasEnded());
- assertEquals("fork", processInstance.getRootToken().getNode().getName());
- for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) {
- Token childToken = (Token) iterator.next();
- assertTrue(childToken.hasEnded());
+ Token rootToken = processInstance.getRootToken();
+ assertEquals("fork", rootToken.getNode().getName());
+ for (Iterator iterator = rootToken.getChildren().values().iterator(); iterator.hasNext();) {
+ Token childToken = (Token) iterator.next();
+ assert !childToken.hasEnded() : childToken;
+ }
+
+ // execute CancelProcessInstanceCommand
+ new CancelProcessInstanceCommand(processInstance.getId()).execute(jbpmContext);
+
+ // and verify it is canceled
+ assert rootToken.hasEnded() : processInstance;
+ assertEquals("fork", rootToken.getNode().getName());
+ for (Iterator iterator = rootToken.getChildren().values().iterator(); iterator.hasNext();) {
+ Token childToken = (Token) iterator.next();
+ assert childToken.hasEnded() : childToken;
+ }
}
+ finally {
+ graphSession.deleteProcessDefinition(processDefinition.getId());
+ }
}
public void testSuspendResumeProcessInstanceCommand() throws Exception {
- String xml = //
- "<?xml version='1.0' encoding='UTF-8'?>" //
- + "<process-definition name='TestException'>" //
- + " <start-state name='start'>" //
- + " <transition to='fork' />" //
- + " </start-state>" //
- + " <fork name='fork'>" //
- + " <transition name='path1' to='path1' />" //
- + " <transition name='path2' to='path2' />" //
- + " </fork>" //
- + " <state name='path1'>" //
- + " <transition to='join' />" //
- + " </state>" //
- + " <state name='path2'>" //
- + " <transition to='join' />" //
- + " </state>" //
- + " <join name='join'>" //
- + " <transition to='end' />" //
- + " </join>" //
- + " <end-state name='end' />" //
- + "</process-definition>";
-
- processDefinition = ProcessDefinition.parseXmlString(xml);
+ String xml = "<?xml version='1.0' encoding='UTF-8'?>"
+ + "<process-definition name='TestException'>"
+ + " <start-state name='start'>"
+ + " <transition to='fork' />"
+ + " </start-state>"
+ + " <fork name='fork'>"
+ + " <transition name='path1' to='path1' />"
+ + " <transition name='path2' to='path2' />"
+ + " </fork>"
+ + " <state name='path1'>"
+ + " <transition to='join' />"
+ + " </state>"
+ + " <state name='path2'>"
+ + " <transition to='join' />"
+ + " </state>"
+ + " <join name='join'>"
+ + " <transition to='end' />"
+ + " </join>"
+ + " <end-state name='end' />"
+ + "</process-definition>";
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(xml);
jbpmContext.deployProcessDefinition(processDefinition);
- ProcessInstance processInstance = processDefinition.createProcessInstance();
- processInstance.getRootToken().signal();
- processInstance = saveAndReload(processInstance);
- assertFalse(processInstance.isSuspended());
- assertFalse(processInstance.getRootToken().isSuspended());
- assertEquals("fork", processInstance.getRootToken().getNode().getName());
- for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) {
- Token childToken = (Token) iterator.next();
- assertFalse(childToken.isSuspended());
- }
+ newTransaction();
+ try {
+ ProcessInstance processInstance = processDefinition.createProcessInstance();
+ processInstance.signal();
- // execute SuspendProcessInstanceCommand
- new SuspendProcessInstanceCommand().processInstanceId(processInstance.getId()).execute(
- jbpmContext);
+ processInstance = saveAndReload(processInstance);
+ assert !processInstance.isSuspended() : processInstance;
- // and verify
- assertTrue(processInstance.isSuspended());
- assertTrue(processInstance.getRootToken().isSuspended());
- assertEquals("fork", processInstance.getRootToken().getNode().getName());
- for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) {
- Token childToken = (Token) iterator.next();
- assertTrue(childToken.isSuspended());
+ Token rootToken = processInstance.getRootToken();
+ assert !rootToken.isSuspended() : rootToken;
+ assertEquals("fork", rootToken.getNode().getName());
+ for (Iterator iterator = rootToken.getChildren().values().iterator(); iterator.hasNext();) {
+ Token childToken = (Token) iterator.next();
+ assert !childToken.isSuspended() : childToken;
+ }
- try {
+ // execute SuspendProcessInstanceCommand
+ new SuspendProcessInstanceCommand().processInstanceId(
+ processInstance.getId()).execute(jbpmContext);
+
+ // and verify
+ assert processInstance.isSuspended() : processInstance;
+ assert rootToken.isSuspended() : rootToken;
+ assertEquals("fork", rootToken.getNode().getName());
+ for (Iterator iterator = rootToken.getChildren().values().iterator(); iterator.hasNext();) {
+ Token childToken = (Token) iterator.next();
+ assert childToken.isSuspended() : childToken;
+
+ try {
+ childToken.signal();
+ fail("signal should not be accepted on suspended token");
+ }
+ catch (JbpmException ex) {
+ // token is suspended
+ assert ex.getMessage().indexOf("suspended") != 0 : ex.getMessage();
+ }
+ }
+
+ // execute ResumeProcessInstanceCommand
+ new ResumeProcessInstanceCommand().processInstanceId(
+ processInstance.getId()).execute(jbpmContext);
+
+ // and verify
+ assert !processInstance.isSuspended() : processInstance;
+ assert !rootToken.isSuspended() : rootToken;
+ for (Iterator iter = rootToken.getChildren().values().iterator(); iter.hasNext();) {
+ Token childToken = (Token) iter.next();
+ assert !childToken.isSuspended() : childToken;
childToken.signal();
- fail("signal should not be accepted on suspended token");
}
- catch (Exception ex) {
- assertEquals(JbpmException.class, ex.getClass());
- // can't signal token 'path1' (5): it is suspended
- assertTrue("exception should be, that token is suspended", ex.getMessage().indexOf(
- "it is suspended") > 0);
- }
- }
- // execute ResumeProcessInstanceCommand
- new ResumeProcessInstanceCommand().processInstanceId(processInstance.getId()).execute(
- jbpmContext);
+ assertEquals("end", rootToken.getNode().getName());
+ assert processInstance.hasEnded() : processInstance;
- // and verify
- assertFalse(processInstance.isSuspended());
- assertFalse(processInstance.getRootToken().isSuspended());
- for (Iterator iterator = processInstance.getRootToken().getChildren().values().iterator(); iterator.hasNext();) {
- Token childToken = (Token) iterator.next();
- assertFalse(childToken.isSuspended());
- childToken.signal();
+ // check db state
+ processInstance = saveAndReload(processInstance);
+ assertEquals("end", processInstance.getRootToken().getNode().getName());
+ assert processInstance.hasEnded() : processInstance;
}
-
- assertEquals("end", processInstance.getRootToken().getNode().getName());
- assertTrue(processInstance.hasEnded());
-
- // check db state
- processInstance = saveAndReload(processInstance);
-
- assertEquals("end", processInstance.getRootToken().getNode().getName());
- assertTrue(processInstance.hasEnded());
+ finally {
+ graphSession.deleteProcessDefinition(processDefinition.getId());
+ }
}
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/TokenCommandTest.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/TokenCommandTest.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/command/TokenCommandTest.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -11,68 +11,71 @@
*
* @author bernd.ruecker at camunda.com
*/
-public class TokenCommandTest extends AbstractDbTestCase
-{
-
+public class TokenCommandTest extends AbstractDbTestCase {
+
public void testUnlockTokenCommand() throws Exception {
- String xml = //
- "<process-definition name='TestException'>" //
- +" <start-state name='start'>" //
- +" <transition to='wait' />" //
- +" </start-state>" //
- +" <state name='wait'>" //
- +" <transition to='end' />" //
- +" </state>" //
- +" <end-state name='end' />" //
- +"</process-definition>";
-
+ String xml = "<process-definition name='TestException'>"
+ + " <start-state name='start'>"
+ + " <transition to='wait' />"
+ + " </start-state>"
+ + " <state name='wait'>"
+ + " <transition to='end' />"
+ + " </state>"
+ + " <end-state name='end' />"
+ + "</process-definition>";
+
ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(xml);
jbpmContext.deployProcessDefinition(processDefinition);
+
+ newTransaction();
try {
- ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("TestException");//processDefinition.createProcessInstance();
+ ProcessInstance processInstance = jbpmContext.newProcessInstance("TestException");
+ long tokenId = processInstance.getRootToken().getId();
processInstance.getRootToken().signal();
processInstance.getRootToken().lock("TEST-OWNER");
- long tokenId = processInstance.getRootToken().getId();
-
- processInstance = saveAndReload(processInstance);
+
+ processInstance = saveAndReload(processInstance);
try {
processInstance.getRootToken().signal();
fail("TOKEN IS LOCKED exception expected");
}
catch (JbpmException ex) {
- // org.jbpm.JbpmException: this token is locked by TEST-OWNER
- assertEquals("this token is locked by TEST-OWNER", ex.getMessage());
+ // token is locked
+ assert ex.getMessage().indexOf("locked") != -1 : ex.getMessage();
}
-
+
// unlocking without owner is a force unlock -> works
new UnlockTokenCommand().tokenId(tokenId).execute(jbpmContext);
-// Token token = jbpmContext.loadTokenForUpdate(processInstance.getRootToken().getId());
-// token.foreUnlock();
-
+
// unlock with same owner
- processInstance = saveAndReload(processInstance);
+ processInstance = saveAndReload(processInstance);
processInstance.getRootToken().lock("TEST-OWNER");
- processInstance = saveAndReload(processInstance);
- new UnlockTokenCommand().lockOwner("TEST-OWNER").tokenId(tokenId).execute(jbpmContext);
-
+
+ processInstance = saveAndReload(processInstance);
+ new UnlockTokenCommand().lockOwner("TEST-OWNER")
+ .tokenId(tokenId)
+ .execute(jbpmContext);
+
// unlocking with wrong owner fails
- processInstance = saveAndReload(processInstance);
+ processInstance = saveAndReload(processInstance);
processInstance.getRootToken().lock("TEST-OWNER");
- processInstance = saveAndReload(processInstance);
+
+ processInstance = saveAndReload(processInstance);
try {
- new UnlockTokenCommand().lockOwner("OTHER-OWNER").tokenId(tokenId).execute(jbpmContext);
- fail("'OTHER-OWNER' can't unlock token exception expected");
+ new UnlockTokenCommand().lockOwner("OTHER-OWNER")
+ .tokenId(tokenId)
+ .execute(jbpmContext);
+ fail("CANNOT UNLOCK TOKEN exception expected");
}
catch (JbpmException ex) {
- // org.jbpm.JbpmException: 'OTHER-OWNER' can't unlock token '1' because it was already locked by 'TEST-OWNER'
- assertTrue("Wrong exception, wasn't 'OTHER-OWNER' can't unlock token", ex.getMessage().indexOf("'OTHER-OWNER' can't unlock token")>=0);
+ // token is locked
+ assert ex.getMessage().indexOf("cannot unlock") != -1 : ex.getMessage();
}
}
finally {
newTransaction();
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ graphSession.deleteProcessDefinition(processDefinition.getId());
}
}
-
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/db/GraphSessionDbTest.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/db/GraphSessionDbTest.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/db/GraphSessionDbTest.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -250,13 +250,15 @@
}
public void testSaveAndLoadProcessInstance() {
- ProcessInstance processInstance = new ProcessInstance();
- processInstance = saveAndReload(processInstance);
+ ProcessDefinition processDefinition = new ProcessDefinition();
+ graphSession.saveProcessDefinition(processDefinition);
try {
+ ProcessInstance processInstance = new ProcessInstance(processDefinition);
+ processInstance = saveAndReload(processInstance);
assertNotNull(processInstance);
}
finally {
- graphSession.deleteProcessInstance(processInstance);
+ graphSession.deleteProcessDefinition(processDefinition);
}
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/graph/node/ProcessStateDbTest.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/graph/node/ProcessStateDbTest.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/graph/node/ProcessStateDbTest.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -22,7 +22,7 @@
package org.jbpm.graph.node;
import org.hibernate.criterion.Order;
-import org.jbpm.JbpmException;
+
import org.jbpm.context.exe.ContextInstance;
import org.jbpm.db.AbstractDbTestCase;
import org.jbpm.graph.def.ProcessDefinition;
@@ -30,50 +30,41 @@
import org.jbpm.graph.exe.Token;
import org.jbpm.graph.log.ProcessStateLog;
-public class ProcessStateDbTest extends AbstractDbTestCase
-{
+public class ProcessStateDbTest extends AbstractDbTestCase {
- public void testProcessStateName()
- {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <process-state name='subprocess' />" +
- "</process-definition>");
+ public void testProcessStateName() {
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <process-state name='subprocess' />"
+ + "</process-definition>");
processDefinition = saveAndReload(processDefinition);
- try
- {
+ try {
ProcessState processState = (ProcessState) processDefinition.getNode("subprocess");
assertEquals("subprocess", processState.getName());
}
- finally
- {
+ finally {
jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition);
}
}
- public void testRecursiveProcessDefinition()
- {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='recursive process'>" +
- " <start-state>" +
- " <transition to='first wait' />" +
- " </start-state>" +
- " <state name='first wait'>" +
- " <transition to='subprocessnode' />" +
- " <transition name='done' to='end' />" +
- " </state>" +
- " <process-state name='subprocessnode'>" +
- " <sub-process name='recursive process' />" +
- " <transition to='end' />" +
- " </process-state>" +
- " <end-state name='end' />" +
- "</process-definition>"
- );
-
+ public void testRecursiveProcessDefinition() {
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='recursive process'>"
+ + " <start-state>"
+ + " <transition to='first wait' />"
+ + " </start-state>"
+ + " <state name='first wait'>"
+ + " <transition to='subprocessnode' />"
+ + " <transition name='done' to='end' />"
+ + " </state>"
+ + " <process-state name='subprocessnode'>"
+ + " <sub-process name='recursive process' />"
+ + " <transition to='end' />"
+ + " </process-state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
+
processDefinition = saveAndReload(processDefinition);
- try
- {
+ try {
ProcessInstance superProcessInstance = processDefinition.createProcessInstance();
superProcessInstance.signal();
superProcessInstance.signal();
@@ -85,7 +76,8 @@
ProcessInstance subProcessInstance = superToken.getSubProcessInstance();
assertNotNull(subProcessInstance);
- assertEquals("recursive process", subProcessInstance.getProcessDefinition().getName());
+ assertEquals("recursive process",
+ subProcessInstance.getProcessDefinition().getName());
Token subToken = subProcessInstance.getRootToken();
assertEquals("first wait", subToken.getNode().getName());
@@ -98,177 +90,165 @@
assertTrue(subProcessInstance.hasEnded());
assertTrue(superProcessInstance.hasEnded());
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinition.getId());
}
}
- public void testMultipleRecursiveProcessDefinitions()
- {
- for (int i=0; i<30; i++) {
+ public void testMultipleRecursiveProcessDefinitions() {
+ for (int i = 0; i < 30; i++) {
testRecursiveProcessDefinition();
newTransaction();
}
}
- public void testProcessStateSubProcessDefinition()
- {
+ public void testProcessStateSubProcessDefinition() {
// create the subprocess
ProcessDefinition subProcessDefinition = new ProcessDefinition("sub");
// store the subprocess in the database
graphSession.saveProcessDefinition(subProcessDefinition);
- try
- {
+ try {
// create the super process
- ProcessDefinition superProcessDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='super'>" +
- " <process-state name='subprocess' />" +
- "</process-definition>");
+ ProcessDefinition superProcessDefinition = ProcessDefinition.parseXmlString("<process-definition name='super'>"
+ + " <process-state name='subprocess' />"
+ + "</process-definition>");
// resolve the reference to the subprocess
ProcessState processState = (ProcessState) superProcessDefinition.getNode("subprocess");
processState.setSubProcessDefinition(subProcessDefinition);
-
+
// save and reload the superprocess
- superProcessDefinition = saveAndReload(superProcessDefinition);
- try
- {
+ superProcessDefinition = saveAndReload(superProcessDefinition);
+ try {
processState = (ProcessState) superProcessDefinition.getNode("subprocess");
assertNotNull("sub", processState.getSubProcessDefinition().getName());
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(superProcessDefinition);
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ superProcessDefinition);
}
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(subProcessDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ subProcessDefinition.getId());
}
}
public void testProcessStateStartVariableMappings() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <process-state name='subprocess'>" +
- " <variable name='startsuperone' access='read,write' mapped-name='startsubone' />" +
- " <variable name='startsupertwo' access='read,write' mapped-name='startsubtwo' />" +
- " <variable name='startsuperthree' access='read,write' mapped-name='startsubthree' />" +
- " </process-state>" +
- "</process-definition>");
-
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <process-state name='subprocess'>"
+ + " <variable name='startsuperone' access='read,write' mapped-name='startsubone' />"
+ + " <variable name='startsupertwo' access='read,write' mapped-name='startsubtwo' />"
+ + " <variable name='startsuperthree' access='read,write' mapped-name='startsubthree' />"
+ + " </process-state>"
+ + "</process-definition>");
+
processDefinition = saveAndReload(processDefinition);
- try
- {
+ try {
ProcessState processState = (ProcessState) processDefinition.getNode("subprocess");
- assertEquals(3, processState.variableAccesses.size() );
+ assertEquals(3, processState.variableAccesses.size());
}
- finally
- {
+ finally {
jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition);
}
}
- public void testSubProcessBindingWithLatestVersion()
- {
+ public void testSubProcessBindingWithLatestVersion() {
final int versionCount = 3;
- for (int i = 0; i < versionCount; i++)
- {
- jbpmContext.deployProcessDefinition(new ProcessDefinition("the multiversion subprocess"));
+ for (int i = 0; i < versionCount; i++) {
+ jbpmContext.deployProcessDefinition(new ProcessDefinition(
+ "the multiversion subprocess"));
}
newTransaction();
- try
- {
- ProcessDefinition processDefinitionTwo = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <process-state name='the sub process state'>" +
- " <sub-process name='the multiversion subprocess'/>" +
- " </process-state>" +
- "</process-definition>"
- );
+ try {
+ ProcessDefinition processDefinitionTwo = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <process-state name='the sub process state'>"
+ + " <sub-process name='the multiversion subprocess'/>"
+ + " </process-state>"
+ + "</process-definition>");
processDefinitionTwo = saveAndReload(processDefinitionTwo);
- try
- {
+ try {
ProcessState processState = (ProcessState) processDefinitionTwo.getNode("the sub process state");
- assertEquals("the multiversion subprocess", processState.getSubProcessDefinition().getName() );
- assertEquals(3, processState.getSubProcessDefinition().getVersion() );
+ assertEquals("the multiversion subprocess",
+ processState.getSubProcessDefinition().getName());
+ assertEquals(3, processState.getSubProcessDefinition().getVersion());
}
- finally
- {
+ finally {
graphSession.deleteProcessDefinition(processDefinitionTwo);
}
}
- finally
- {
- for (int i = 1; i <= versionCount; i++)
- {
- ProcessDefinition processDefinition = graphSession.findProcessDefinition("the multiversion subprocess", i);
+ finally {
+ for (int i = 1; i <= versionCount; i++) {
+ ProcessDefinition processDefinition = graphSession.findProcessDefinition(
+ "the multiversion subprocess", i);
graphSession.deleteProcessDefinition(processDefinition);
- }
- }
+ }
+ }
}
- public void testAverageSubProcess()
- {
- ProcessDefinition subProcessDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='subprocess'>" +
- " <start-state name='start'>" +
- " <transition to='wait' />" +
- " </start-state>" +
- " <state name='wait'>" +
- " <transition to='end' />" +
- " </state>" +
- " <end-state name='end' />" +
- "</process-definition>");
+ public void testAverageSubProcess() {
+ ProcessDefinition subProcessDefinition = ProcessDefinition.parseXmlString("<process-definition name='subprocess'>"
+ + " <start-state name='start'>"
+ + " <transition to='wait' />"
+ + " </start-state>"
+ + " <state name='wait'>"
+ + " <transition to='end' />"
+ + " </state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(subProcessDefinition);
-
- ProcessDefinition superProcessDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='superprocess'>" +
- " <start-state name='start'>" +
- " <transition to='sub process state' />" +
- " </start-state>" +
- " <process-state name='sub process state'>" +
- " <sub-process name='subprocess' />" +
- " <variable name='a' access='read' mapped-name='A' />" +
- " <variable name='b' mapped-name='B' />" +
- " <variable name='c' access='write' mapped-name='C' />" +
- " <transition to='wait' />" +
- " </process-state>" +
- " <state name='wait' />" +
- "</process-definition>");
+
+ ProcessDefinition superProcessDefinition = ProcessDefinition.parseXmlString("<process-definition name='superprocess'>"
+ + " <start-state name='start'>"
+ + " <transition to='sub process state' />"
+ + " </start-state>"
+ + " <process-state name='sub process state'>"
+ + " <sub-process name='subprocess' />"
+ + " <variable name='a' access='read' mapped-name='A' />"
+ + " <variable name='b' mapped-name='B' />"
+ + " <variable name='c' access='write' mapped-name='C' />"
+ + " <transition to='wait' />"
+ + " </process-state>"
+ + " <state name='wait' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(superProcessDefinition);
- try
- {
+ try {
newTransaction();
-
+
ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("superprocess");
ContextInstance contextInstance = processInstance.getContextInstance();
contextInstance.setVariable("a", "1");
contextInstance.setVariable("b", "1");
contextInstance.setVariable("c", "1");
processInstance.signal();
-
+
newTransaction();
long processInstanceId = processInstance.getId();
- long subProcessInstanceId = processInstance.getRootToken().getSubProcessInstance().getId();
+ long subProcessInstanceId = processInstance.getRootToken()
+ .getSubProcessInstance()
+ .getId();
processInstance = jbpmContext.loadProcessInstance(processInstanceId);
assertNotNull(processInstance.getRootToken().getSubProcessInstance());
- assertEquals("sub process state", processInstance.getRootToken().getNode().getName());
+ assertEquals("sub process state", processInstance.getRootToken()
+ .getNode()
+ .getName());
contextInstance = processInstance.getContextInstance();
- assertEquals("1", contextInstance.getVariable("a") );
- assertEquals("1", contextInstance.getVariable("b") );
- assertEquals("1", contextInstance.getVariable("c") );
+ assertEquals("1", contextInstance.getVariable("a"));
+ assertEquals("1", contextInstance.getVariable("b"));
+ assertEquals("1", contextInstance.getVariable("c"));
ProcessInstance subProcessInstance = jbpmContext.loadProcessInstance(subProcessInstanceId);
- assertEquals("wait", subProcessInstance.getRootToken().getNode().getName());
+ assertEquals("wait", subProcessInstance.getRootToken()
+ .getNode()
+ .getName());
ContextInstance subContextInstance = subProcessInstance.getContextInstance();
- assertEquals("1", subContextInstance.getVariable("A") );
- assertEquals("1", subContextInstance.getVariable("B") );
- assertNull(subContextInstance.getVariable("C") );
-
+ assertEquals("1", subContextInstance.getVariable("A"));
+ assertEquals("1", subContextInstance.getVariable("B"));
+ assertNull(subContextInstance.getVariable("C"));
+
subContextInstance.setVariable("A", "2");
subContextInstance.setVariable("B", "2");
subContextInstance.setVariable("C", "2");
@@ -278,257 +258,270 @@
newTransaction();
- assertTrue(jbpmContext.loadProcessInstance(subProcessInstanceId).hasEnded());
-
+ assertTrue(jbpmContext.loadProcessInstance(subProcessInstanceId)
+ .hasEnded());
+
processInstance = jbpmContext.loadProcessInstance(processInstanceId);
assertEquals("wait", processInstance.getRootToken().getNode().getName());
contextInstance = processInstance.getContextInstance();
- assertEquals("1", contextInstance.getVariable("a") );
- assertEquals("2", contextInstance.getVariable("b") );
- assertEquals("2", contextInstance.getVariable("c") );
+ assertEquals("1", contextInstance.getVariable("a"));
+ assertEquals("2", contextInstance.getVariable("b"));
+ assertEquals("2", contextInstance.getVariable("c"));
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(superProcessDefinition.getId());
- jbpmContext.getGraphSession().deleteProcessDefinition(subProcessDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ superProcessDefinition.getId());
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ subProcessDefinition.getId());
}
}
- public void testSubProcessBindingByVersion()
- {
- ProcessDefinition processDefinitionOne = new ProcessDefinition("the ultimate subprocess");
+ public void testSubProcessBindingByVersion() {
+ ProcessDefinition processDefinitionOne = new ProcessDefinition(
+ "the ultimate subprocess");
jbpmContext.deployProcessDefinition(processDefinitionOne);
newTransaction();
- ProcessDefinition processDefinitionTwo = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <process-state name='the sub process state'>" +
- " <sub-process name='the ultimate subprocess' version='1' />" +
- " </process-state>" +
- "</process-definition>"
- );
+ ProcessDefinition processDefinitionTwo = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <process-state name='the sub process state'>"
+ + " <sub-process name='the ultimate subprocess' version='1' />"
+ + " </process-state>"
+ + "</process-definition>");
processDefinitionTwo = saveAndReload(processDefinitionTwo);
- try
- {
+ try {
ProcessState processState = (ProcessState) processDefinitionTwo.getNode("the sub process state");
- assertEquals("the ultimate subprocess", processState.getSubProcessDefinition().getName() );
- assertEquals(1, processState.getSubProcessDefinition().getVersion() );
+ assertEquals("the ultimate subprocess",
+ processState.getSubProcessDefinition().getName());
+ assertEquals(1, processState.getSubProcessDefinition().getVersion());
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinitionOne.getId());
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinitionTwo);
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinitionOne.getId());
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinitionTwo);
}
}
public void testSubProcessLogs() {
- ProcessDefinition subProcessDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='subprocess'>" +
- " <start-state name='start'>" +
- " <transition to='wait' />" +
- " </start-state>" +
- " <state name='wait'>" +
- " <transition to='end' />" +
- " </state>" +
- " <end-state name='end' />" +
- "</process-definition>");
+ ProcessDefinition subProcessDefinition = ProcessDefinition.parseXmlString("<process-definition name='subprocess'>"
+ + " <start-state name='start'>"
+ + " <transition to='wait' />"
+ + " </start-state>"
+ + " <state name='wait'>"
+ + " <transition to='end' />"
+ + " </state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(subProcessDefinition);
-
- ProcessDefinition superProcessDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='superprocess'>" +
- " <start-state name='start'>" +
- " <transition to='sub process state' />" +
- " </start-state>" +
- " <process-state name='sub process state'>" +
- " <sub-process name='subprocess' />" +
- " <transition to='wait' />" +
- " </process-state>" +
- " <state name='wait' />" +
- "</process-definition>");
+
+ ProcessDefinition superProcessDefinition = ProcessDefinition.parseXmlString("<process-definition name='superprocess'>"
+ + " <start-state name='start'>"
+ + " <transition to='sub process state' />"
+ + " </start-state>"
+ + " <process-state name='sub process state'>"
+ + " <sub-process name='subprocess' />"
+ + " <transition to='wait' />"
+ + " </process-state>"
+ + " <state name='wait' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(superProcessDefinition);
-
- try
- {
+
+ try {
newTransaction();
-
+
ProcessInstance superProcessInstance = jbpmContext.newProcessInstanceForUpdate("superprocess");
superProcessInstance.signal();
-
+
newTransaction();
- long subProcessInstanceId = superProcessInstance.getRootToken().getSubProcessInstance().getId();
+ long subProcessInstanceId = superProcessInstance.getRootToken()
+ .getSubProcessInstance()
+ .getId();
ProcessInstance subProcessInstance = jbpmContext.loadProcessInstance(subProcessInstanceId);
subProcessInstance.signal();
jbpmContext.save(subProcessInstance);
newTransaction();
- ProcessStateLog processStateLog = (ProcessStateLog) session.createCriteria(ProcessStateLog.class)
+ ProcessStateLog processStateLog = (ProcessStateLog) session.createCriteria(
+ ProcessStateLog.class)
.addOrder(Order.desc("enter"))
.setMaxResults(1)
.uniqueResult();
- assertEquals(subProcessInstanceId, processStateLog.getSubProcessInstance().getId());
- assertEquals(superProcessInstance.getId(), processStateLog.getToken().getProcessInstance().getId());
+ assertEquals(subProcessInstanceId,
+ processStateLog.getSubProcessInstance().getId());
+ assertEquals(superProcessInstance.getId(), processStateLog.getToken()
+ .getProcessInstance()
+ .getId());
}
- finally
- {
+ finally {
graphSession.deleteProcessDefinition(subProcessDefinition.getId());
graphSession.deleteProcessDefinition(superProcessDefinition.getId());
}
}
- public void testDynamicProcessBinding()
- {
- ProcessDefinition processDefinitionOne = ProcessDefinition.parseXmlString(
- "<process-definition name='subprocess1'>" +
- " <start-state name='start'>" +
- " <transition to='wait subprocess 1' />" +
- " </start-state>" +
- " <state name='wait subprocess 1'>" +
- " <transition to='end' />" +
- " </state>" +
- " <end-state name='end' />" +
- "</process-definition>");
+ public void testDynamicProcessBinding() {
+ ProcessDefinition processDefinitionOne = ProcessDefinition.parseXmlString("<process-definition name='subprocess1'>"
+ + " <start-state name='start'>"
+ + " <transition to='wait subprocess 1' />"
+ + " </start-state>"
+ + " <state name='wait subprocess 1'>"
+ + " <transition to='end' />"
+ + " </state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(processDefinitionOne);
-
- ProcessDefinition processDefinitionTwo = ProcessDefinition.parseXmlString(
- "<process-definition name='subprocess2'>" +
- " <start-state name='start'>" +
- " <transition to='wait subprocess 2' />" +
- " </start-state>" +
- " <state name='wait subprocess 2'>" +
- " <transition to='end' />" +
- " </state>" +
- " <end-state name='end' />" +
- "</process-definition>");
- jbpmContext.deployProcessDefinition(processDefinitionTwo);
-
- ProcessDefinition processDefinitionThree = ProcessDefinition.parseXmlString(
- "<process-definition name='superprocess'>" +
- " <start-state name='start'>" +
- " <transition to='sub process state' />" +
- " </start-state>" +
- " <process-state name='sub process state'>" +
- " <sub-process name='#{mySubProcess}' binding='late'/>" +
- " <transition to='wait' />" +
- " </process-state>" +
- " <state name='wait' />" +
- "</process-definition>");
+
+ ProcessDefinition processDefinitionTwo = ProcessDefinition.parseXmlString("<process-definition name='subprocess2'>"
+ + " <start-state name='start'>"
+ + " <transition to='wait subprocess 2' />"
+ + " </start-state>"
+ + " <state name='wait subprocess 2'>"
+ + " <transition to='end' />"
+ + " </state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
+ jbpmContext.deployProcessDefinition(processDefinitionTwo);
+
+ ProcessDefinition processDefinitionThree = ProcessDefinition.parseXmlString("<process-definition name='superprocess'>"
+ + " <start-state name='start'>"
+ + " <transition to='sub process state' />"
+ + " </start-state>"
+ + " <process-state name='sub process state'>"
+ + " <sub-process name='#{mySubProcess}' binding='late'/>"
+ + " <transition to='wait' />"
+ + " </process-state>"
+ + " <state name='wait' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(processDefinitionThree);
- try
- {
+ try {
newTransaction();
-
+
ProcessInstance processInstance1 = jbpmContext.newProcessInstanceForUpdate("superprocess");
ContextInstance contextInstance = processInstance1.getContextInstance();
contextInstance.setVariable("mySubProcess", "subprocess1");
processInstance1.signal();
-
+
newTransaction();
long processInstanceId = processInstance1.getId();
- long subProcessInstanceId = processInstance1.getRootToken().getSubProcessInstance().getId();
- // System.out.println("process ID: " + processInstanceId + " subprocess ID: " + subProcessInstanceId);
-
+ long subProcessInstanceId = processInstance1.getRootToken()
+ .getSubProcessInstance()
+ .getId();
+ // System.out.println("process ID: " + processInstanceId +
+ // " subprocess ID: " + subProcessInstanceId);
+
processInstance1 = jbpmContext.loadProcessInstance(processInstanceId);
assertNotNull(processInstance1.getRootToken().getSubProcessInstance());
- assertEquals("sub process state", processInstance1.getRootToken().getNode().getName());
+ assertEquals("sub process state", processInstance1.getRootToken()
+ .getNode()
+ .getName());
contextInstance = processInstance1.getContextInstance();
- assertEquals("subprocess1", contextInstance.getVariable("mySubProcess") );
+ assertEquals("subprocess1", contextInstance.getVariable("mySubProcess"));
ProcessInstance subProcessInstance1 = jbpmContext.loadProcessInstance(subProcessInstanceId);
- assertEquals("subprocess1", subProcessInstance1.getProcessDefinition().getName());
- assertEquals("wait subprocess 1", subProcessInstance1.getRootToken().getNode().getName());
+ assertEquals("subprocess1", subProcessInstance1.getProcessDefinition()
+ .getName());
+ assertEquals("wait subprocess 1", subProcessInstance1.getRootToken()
+ .getNode()
+ .getName());
subProcessInstance1.signal();
jbpmContext.save(subProcessInstance1);
newTransaction();
- assertTrue(jbpmContext.loadProcessInstance(subProcessInstanceId).hasEnded());
-
+ assertTrue(jbpmContext.loadProcessInstance(subProcessInstanceId)
+ .hasEnded());
+
processInstance1 = jbpmContext.loadProcessInstance(processInstanceId);
assertEquals("wait", processInstance1.getRootToken().getNode().getName());
-
+
newTransaction();
-
+
ProcessInstance processInstance2 = jbpmContext.newProcessInstanceForUpdate("superprocess");
ContextInstance contextInstance2 = processInstance2.getContextInstance();
contextInstance2.setVariable("mySubProcess", "subprocess2");
processInstance2.signal();
-
+
newTransaction();
long processInstanceId2 = processInstance2.getId();
- long subProcessInstanceId2 = processInstance2.getRootToken().getSubProcessInstance().getId();
- // System.out.println("process ID: " + processInstanceId2 + " subprocess ID: " + subProcessInstanceId2);
-
+ long subProcessInstanceId2 = processInstance2.getRootToken()
+ .getSubProcessInstance()
+ .getId();
+ // System.out.println("process ID: " + processInstanceId2 +
+ // " subprocess ID: " + subProcessInstanceId2);
+
processInstance2 = jbpmContext.loadProcessInstance(processInstanceId2);
assertNotNull(processInstance2.getRootToken().getSubProcessInstance());
- assertEquals("sub process state", processInstance2.getRootToken().getNode().getName());
+ assertEquals("sub process state", processInstance2.getRootToken()
+ .getNode()
+ .getName());
contextInstance2 = processInstance2.getContextInstance();
- assertEquals("subprocess2", contextInstance2.getVariable("mySubProcess") );
+ assertEquals("subprocess2", contextInstance2.getVariable("mySubProcess"));
ProcessInstance subProcessInstance2 = jbpmContext.loadProcessInstance(subProcessInstanceId2);
- assertEquals("subprocess2", subProcessInstance2.getProcessDefinition().getName());
- assertEquals("wait subprocess 2", subProcessInstance2.getRootToken().getNode().getName());
+ assertEquals("subprocess2", subProcessInstance2.getProcessDefinition()
+ .getName());
+ assertEquals("wait subprocess 2", subProcessInstance2.getRootToken()
+ .getNode()
+ .getName());
subProcessInstance2.signal();
jbpmContext.save(subProcessInstance2);
newTransaction();
- assertTrue(jbpmContext.loadProcessInstance(subProcessInstanceId2).hasEnded());
-
+ assertTrue(jbpmContext.loadProcessInstance(subProcessInstanceId2)
+ .hasEnded());
+
processInstance2 = jbpmContext.loadProcessInstance(processInstanceId2);
assertEquals("wait", processInstance2.getRootToken().getNode().getName());
}
- finally
- {
+ finally {
newTransaction();
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinitionOne.getId());
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinitionTwo.getId());
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinitionThree.getId());
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinitionOne.getId());
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinitionTwo.getId());
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinitionThree.getId());
}
- }
+ }
- public void testUnboundSubProcess()
- {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='superprocess'>" +
- " <start-state name='start'>" +
- " <transition to='sub process state' />" +
- " </start-state>" +
- " <process-state name='sub process state'>" +
- " <sub-process name='subprocess' binding='late' />" +
- " <transition to='wait' />" +
- " </process-state>" +
- " <state name='wait' />" +
- "</process-definition>");
-
+ public void testUnboundSubProcess() {
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='superprocess'>"
+ + " <start-state name='start'>"
+ + " <transition to='sub process state' />"
+ + " </start-state>"
+ + " <process-state name='sub process state'>"
+ + " <sub-process name='subprocess' binding='late' />"
+ + " <transition to='wait' />"
+ + " </process-state>"
+ + " <state name='wait' />"
+ + "</process-definition>");
+
jbpmContext.deployProcessDefinition(processDefinition);
- try
- {
+ try {
newTransaction();
- ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("superprocess");
- try
- {
+ ProcessInstance processInstance = jbpmContext.newProcessInstance("superprocess");
+ try {
processInstance.signal();
fail("expected exception");
}
- catch (JbpmException e)
- {
+ catch (IllegalArgumentException e) {
// expected
jbpmContext.setRollbackOnly();
}
}
- finally
- {
+ finally {
newTransaction();
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinition.getId());
}
}
}
Modified: jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/taskmgmt/exe/EndTasksDbTest.java
===================================================================
--- jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/taskmgmt/exe/EndTasksDbTest.java 2010-01-16 00:21:04 UTC (rev 6084)
+++ jbpm3/branches/jbpm-3.2-soa/modules/core/src/test/java/org/jbpm/taskmgmt/exe/EndTasksDbTest.java 2010-01-16 03:29:46 UTC (rev 6085)
@@ -1,7 +1,6 @@
package org.jbpm.taskmgmt.exe;
import java.util.Collection;
-import java.util.Iterator;
import org.jbpm.db.AbstractDbTestCase;
import org.jbpm.graph.def.ActionHandler;
@@ -9,172 +8,165 @@
import org.jbpm.graph.exe.ExecutionContext;
import org.jbpm.graph.exe.ProcessInstance;
-public class EndTasksDbTest extends AbstractDbTestCase
-{
-
- public static class Buzz implements ActionHandler
- {
+public class EndTasksDbTest extends AbstractDbTestCase {
+
+ public static class Buzz implements ActionHandler {
private static final long serialVersionUID = 1L;
- public void execute(ExecutionContext executionContext) throws Exception
- {
+ public void execute(ExecutionContext executionContext) throws Exception {
throw new RuntimeException("buzz");
}
}
- public void testCancel()
- {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='endtasksprocess'>" +
- " <start-state>" +
- " <transition to='approval' />" +
- " </start-state>" +
- " <task-node name='approval' end-tasks='true'>" +
- " <task name='approve' description='Review order'>" +
- " <assignment pooled-actors='reviewers' />" +
- " </task>" +
- " <transition name='approve' to='process'>" +
- " <action class='"+Buzz.class.getName()+"' />" +
- " </transition>" +
- " <transition name='cancel' to='cancelled'/>" +
- " </task-node>" +
- " <state name='process' />" +
- " <state name='cancelled' />" +
- "</process-definition>"
- );
-
+ public void testCancel() {
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='endtasksprocess'>"
+ + " <start-state>"
+ + " <transition to='approval' />"
+ + " </start-state>"
+ + " <task-node name='approval' end-tasks='true'>"
+ + " <task name='approve' description='Review order'>"
+ + " <assignment pooled-actors='reviewers' />"
+ + " </task>"
+ + " <transition name='approve' to='process'>"
+ + " <action class='"
+ + Buzz.class.getName()
+ + "' />"
+ + " </transition>"
+ + " <transition name='cancel' to='cancelled'/>"
+ + " </task-node>"
+ + " <state name='process' />"
+ + " <state name='cancelled' />" + "</process-definition>");
+
jbpmContext.deployProcessDefinition(processDefinition);
- try
- {
- ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("endtasksprocess");
+ newTransaction();
+
+ try {
+ ProcessInstance processInstance = jbpmContext.newProcessInstance("endtasksprocess");
processInstance.signal();
processInstance = saveAndReload(processInstance);
+ assertEquals("approval", processInstance.getRootToken()
+ .getNode()
+ .getName());
- assertEquals("approval", processInstance.getRootToken().getNode().getName());
processInstance = saveAndReload(processInstance);
processInstance.signal("cancel");
- assertEquals("cancelled", processInstance.getRootToken().getNode().getName());
+ assertEquals("cancelled", processInstance.getRootToken()
+ .getNode()
+ .getName());
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinition.getId());
}
}
- public void testApprove()
- {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='endtasksprocess'>" +
- " <start-state>" +
- " <transition to='approval' />" +
- " </start-state>" +
- " <task-node name='approval' end-tasks='true'>" +
- " <task name='approve' description='Review order'>" +
- " <assignment pooled-actors='reviewers' />" +
- " </task>" +
- " <transition name='approve' to='process'/>" +
- " <transition name='reject' to='cancelled'/>" +
- " <transition name='cancel' to='cancelled'/>" +
- " </task-node>" +
- " <state name='process' />" +
- " <state name='cancelled' />" +
- "</process-definition>"
- );
+ public void testApprove() {
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='endtasksprocess'>"
+ + " <start-state>"
+ + " <transition to='approval' />"
+ + " </start-state>"
+ + " <task-node name='approval' end-tasks='true'>"
+ + " <task name='approve' description='Review order'>"
+ + " <assignment pooled-actors='reviewers' />"
+ + " </task>"
+ + " <transition name='approve' to='process'/>"
+ + " <transition name='reject' to='cancelled'/>"
+ + " <transition name='cancel' to='cancelled'/>"
+ + " </task-node>"
+ + " <state name='process' />"
+ + " <state name='cancelled' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(processDefinition);
- try
- {
- newTransaction();
+ newTransaction();
+ try {
ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("endtasksprocess");
processInstance.signal();
processInstance = saveAndReload(processInstance);
+ assertEquals("approval", processInstance.getRootToken()
+ .getNode()
+ .getName());
- assertEquals("approval", processInstance.getRootToken().getNode().getName());
- TaskInstance taskInstance = (TaskInstance) processInstance
- .getTaskMgmtInstance()
+ TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance()
.getTaskInstances()
.iterator()
.next();
-
taskInstance.end("approve");
- assertEquals("process", processInstance.getRootToken().getNode().getName());
+ assertEquals("process", processInstance.getRootToken()
+ .getNode()
+ .getName());
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinition.getId());
}
}
- public void testReject()
- {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='endtasksprocess'>" +
- " <start-state>" +
- " <transition to='approval' />" +
- " </start-state>" +
- " <task-node name='approval' end-tasks='true'>" +
- " <task name='approve' description='Review order'>" +
- " <assignment pooled-actors='reviewers' />" +
- " </task>" +
- " <transition name='approve' to='process'/>" +
- " <transition name='reject' to='cancelled'/>" +
- " <transition name='cancel' to='cancelled'/>" +
- " </task-node>" +
- " <state name='process' />" +
- " <state name='cancelled' />" +
- "</process-definition>"
- );
+ public void testReject() {
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='endtasksprocess'>"
+ + " <start-state>"
+ + " <transition to='approval' />"
+ + " </start-state>"
+ + " <task-node name='approval' end-tasks='true'>"
+ + " <task name='approve' description='Review order'>"
+ + " <assignment pooled-actors='reviewers' />"
+ + " </task>"
+ + " <transition name='approve' to='process'/>"
+ + " <transition name='reject' to='cancelled'/>"
+ + " <transition name='cancel' to='cancelled'/>"
+ + " </task-node>"
+ + " <state name='process' />"
+ + " <state name='cancelled' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(processDefinition);
- try
- {
- newTransaction();
+ newTransaction();
+ try {
ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("endtasksprocess");
processInstance.signal();
processInstance = saveAndReload(processInstance);
+ assertEquals("approval", processInstance.getRootToken()
+ .getNode()
+ .getName());
- assertEquals("approval", processInstance.getRootToken().getNode().getName());
- TaskInstance taskInstance = (TaskInstance) processInstance
- .getTaskMgmtInstance()
+ TaskInstance taskInstance = (TaskInstance) processInstance.getTaskMgmtInstance()
.getTaskInstances()
.iterator()
.next();
-
taskInstance.end("reject");
- assertEquals("cancelled", processInstance.getRootToken().getNode().getName());
+ assertEquals("cancelled", processInstance.getRootToken()
+ .getNode()
+ .getName());
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinition.getId());
}
}
public void testTaskInstancesAfterCancellation() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition name='endtasksprocess'>" +
- " <start-state>" +
- " <transition to='approval' />" +
- " </start-state>" +
- " <task-node name='approval' end-tasks='true'>" +
- " <task name='approve' description='Review order'>" +
- " <assignment pooled-actors='reviewers' />" +
- " </task>" +
- " <transition name='approve' to='process'/>" +
- " <transition name='reject' to='cancelled'/>" +
- " <transition name='cancel' to='cancelled'/>" +
- " </task-node>" +
- " <state name='process' />" +
- " <state name='cancelled' />" +
- "</process-definition>"
- );
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition name='endtasksprocess'>"
+ + " <start-state>"
+ + " <transition to='approval' />"
+ + " </start-state>"
+ + " <task-node name='approval' end-tasks='true'>"
+ + " <task name='approve' description='Review order'>"
+ + " <assignment pooled-actors='reviewers' />"
+ + " </task>"
+ + " <transition name='approve' to='process'/>"
+ + " <transition name='reject' to='cancelled'/>"
+ + " <transition name='cancel' to='cancelled'/>"
+ + " </task-node>"
+ + " <state name='process' />"
+ + " <state name='cancelled' />"
+ + "</process-definition>");
jbpmContext.deployProcessDefinition(processDefinition);
- try
- {
- newTransaction();
+ newTransaction();
+ try {
ProcessInstance processInstance = jbpmContext.newProcessInstanceForUpdate("endtasksprocess");
processInstance.signal();
@@ -182,19 +174,20 @@
processInstance = saveAndReload(processInstance);
processInstance.signal("cancel");
- Collection taskInstances = processInstance.getTaskMgmtInstance().getTaskInstances();
- Iterator iter = taskInstances.iterator();
- while(iter.hasNext()) {
- TaskInstance taskInstance = (TaskInstance) iter.next();
- assertTrue(taskInstance.getName()+" ended", taskInstance.hasEnded());
- assertFalse(taskInstance.getName()+" not cancelled", taskInstance.isCancelled());
- assertFalse(taskInstance.getName()+" not blocking", taskInstance.isBlocking());
- assertFalse(taskInstance.getName()+" not signalling", taskInstance.isSignalling());
- }
+ Collection taskInstances = processInstance.getTaskMgmtInstance()
+ .getTaskInstances();
+ assertEquals(1, taskInstances.size());
+
+ TaskInstance taskInstance = (TaskInstance) taskInstances.iterator()
+ .next();
+ assert taskInstance.hasEnded() : taskInstance;
+ assert !taskInstance.isCancelled() : taskInstance;
+ assert !taskInstance.isBlocking() : taskInstance;
+ assert !taskInstance.isSignalling() : taskInstance;
}
- finally
- {
- jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
+ finally {
+ jbpmContext.getGraphSession().deleteProcessDefinition(
+ processDefinition.getId());
}
}
}
More information about the jbpm-commits
mailing list