[jbpm-commits] JBoss JBPM SVN: r2927 - in projects/spec/trunk/modules: api/src/main/java/org/jbpm/preview/model and 5 other directories.

do-not-reply at jboss.org do-not-reply at jboss.org
Fri Nov 14 06:59:25 EST 2008


Author: thomas.diesler at jboss.com
Date: 2008-11-14 06:59:25 -0500 (Fri, 14 Nov 2008)
New Revision: 2927

Added:
   projects/spec/trunk/modules/api/src/main/java/org/jbpm/api/model/ExclusiveGateway.java
   projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitMarshallerTest.java
   projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateMarshallerTest.java
   projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshallerExt.java
   projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshallerExt.java
Removed:
   projects/spec/trunk/modules/api/src/main/java/org/jbpm/preview/model/ExclusiveGateway.java
Modified:
   projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitTest.java
   projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateTest.java
   projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshaller.java
   projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshaller.java
   projects/spec/trunk/modules/ri/src/main/java/org/jbpm/ri/model/ExclusiveGatewayImpl.java
   projects/spec/trunk/modules/ri/src/test/java/org/jbpm/test/ri/service/persistence/ExclusiveGatewayPersistenceTest.java
Log:
Add marshaller tests

Copied: projects/spec/trunk/modules/api/src/main/java/org/jbpm/api/model/ExclusiveGateway.java (from rev 2924, projects/spec/trunk/modules/api/src/main/java/org/jbpm/preview/model/ExclusiveGateway.java)
===================================================================
--- projects/spec/trunk/modules/api/src/main/java/org/jbpm/api/model/ExclusiveGateway.java	                        (rev 0)
+++ projects/spec/trunk/modules/api/src/main/java/org/jbpm/api/model/ExclusiveGateway.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -0,0 +1,58 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jbpm.api.model;
+
+
+
+//$Id$
+
+/**
+ * Exclusive Gateways (Decisions) are locations within a business process where the Sequence Flow can take two or more
+ * alternative paths. This is basically the “fork in the road” for a process. For a given performance (or instance) of the
+ * process, only one of the paths can be taken (this should not be confused with forking of paths—refer to “Forking Flow”)
+ * 
+ * A Decision is not an activity from the business process perspective, but is a type of Gateway that controls
+ * the Sequence Flow between activities. It can be thought of as a question that is asked at that point in the Process. The
+ * question has a defined set of alternative answers (Gates). Each Decision Gate is associated with a condition expression
+ * found within an outgoing Sequence Flow. When a Gate is chosen during the performance of the Process, the
+ * corresponding Sequence Flow is then chosen. A Token arriving at the Decision would be directed down the appropriate
+ * path, based on the chosen Gate.
+ * 
+ * The Exclusive Decision has two or more outgoing Sequence Flow, but only one of them may be taken during the
+ * performance of the Process. Thus, the Exclusive Decision defines a set of alternative paths for the Token to take as it
+ * traverses the Flow. There are two types of Exclusive Decisions: Data-Based and Event-Based.
+ * 
+ * @author thomas.diesler at jboss.com
+ * @since 08-Jul-2008
+ */
+public interface ExclusiveGateway extends Gateway
+{
+  enum ExclusiveType
+  {
+    Data, Event
+  }
+  
+  /**
+   * ExclusiveType is by default Data. The ExclusiveType MAY be set to Event.
+   */
+  ExclusiveType getExclusiveType();
+}
\ No newline at end of file

Deleted: projects/spec/trunk/modules/api/src/main/java/org/jbpm/preview/model/ExclusiveGateway.java
===================================================================
--- projects/spec/trunk/modules/api/src/main/java/org/jbpm/preview/model/ExclusiveGateway.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/api/src/main/java/org/jbpm/preview/model/ExclusiveGateway.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -1,59 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source
- * Copyright 2005, JBoss Inc., and individual contributors as indicated
- * by the @authors tag. See the copyright.txt in the distribution for a
- * full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jbpm.preview.model;
-
-import org.jbpm.api.model.Gateway;
-
-
-//$Id$
-
-/**
- * Exclusive Gateways (Decisions) are locations within a business process where the Sequence Flow can take two or more
- * alternative paths. This is basically the “fork in the road” for a process. For a given performance (or instance) of the
- * process, only one of the paths can be taken (this should not be confused with forking of paths—refer to “Forking Flow”)
- * 
- * A Decision is not an activity from the business process perspective, but is a type of Gateway that controls
- * the Sequence Flow between activities. It can be thought of as a question that is asked at that point in the Process. The
- * question has a defined set of alternative answers (Gates). Each Decision Gate is associated with a condition expression
- * found within an outgoing Sequence Flow. When a Gate is chosen during the performance of the Process, the
- * corresponding Sequence Flow is then chosen. A Token arriving at the Decision would be directed down the appropriate
- * path, based on the chosen Gate.
- * 
- * The Exclusive Decision has two or more outgoing Sequence Flow, but only one of them may be taken during the
- * performance of the Process. Thus, the Exclusive Decision defines a set of alternative paths for the Token to take as it
- * traverses the Flow. There are two types of Exclusive Decisions: Data-Based and Event-Based.
- * 
- * @author thomas.diesler at jboss.com
- * @since 08-Jul-2008
- */
-public interface ExclusiveGateway extends Gateway
-{
-  enum ExclusiveType
-  {
-    Data, Event
-  }
-  
-  /**
-   * ExclusiveType is by default Data. The ExclusiveType MAY be set to Event.
-   */
-  ExclusiveType getExclusiveType();
-}
\ No newline at end of file

Added: projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitMarshallerTest.java
===================================================================
--- projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitMarshallerTest.java	                        (rev 0)
+++ projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitMarshallerTest.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -0,0 +1,52 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jbpm.test.cts.gateway.exclusive;
+
+// $Id$
+
+import java.io.IOException;
+
+import org.jbpm.api.model.ProcessDefinition;
+import org.jbpm.api.service.ProcessDefinitionService;
+
+/**
+ * Exclusive data-based gateway that has conditional outgoing sequence flows. Only one of the gates is taken. It is an
+ * error if no gate is applicable.
+ * 
+ * @author thomas.diesler at jboss.com
+ * @since 06-Aug-2008
+ */
+public class ExclusiveGatewaySplitMarshallerTest extends ExclusiveGatewaySplitTest
+{
+  protected ProcessDefinition getProcessDefinition() throws IOException
+  {
+    // Marshall the process to a string
+    ProcessDefinition procDef = super.getProcessDefinition();
+    String procXML = marshallProcess(procDef);
+
+    //System.out.println(procXML);
+
+    // Recreate the ProcessDefinition from the marshalled ProcessDefinition
+    ProcessDefinitionService pdService = getProcessEngine().getService(ProcessDefinitionService.class);
+    return pdService.createProcessDefinition(procXML);
+  }
+}


Property changes on: projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitMarshallerTest.java
___________________________________________________________________
Name: svn:keywords
   + Id Revision
Name: svn:eol-style
   + LF

Modified: projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitTest.java
===================================================================
--- projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitTest.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/gateway/exclusive/ExclusiveGatewaySplitTest.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -100,7 +100,7 @@
     }
   }
 
-  public ProcessDefinition getProcessDefinition() throws IOException
+  protected ProcessDefinition getProcessDefinition() throws IOException
   {
     ProcessBuilder procBuilder = ProcessBuilderService.locateProcessBuilder();
     procBuilder.addProcess(getName()).addStartEvent("Start").addSequenceFlow("Split");

Added: projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateMarshallerTest.java
===================================================================
--- projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateMarshallerTest.java	                        (rev 0)
+++ projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateMarshallerTest.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -0,0 +1,52 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jbpm.test.cts.task.waitstate;
+
+import java.io.IOException;
+
+import org.jbpm.api.model.ProcessDefinition;
+import org.jbpm.api.service.ProcessDefinitionService;
+
+// $Id$
+
+
+/**
+ * Test the basic wait state sequence
+ * 
+ * @author thomas.diesler at jboss.com
+ * @since 10-Nov-2008
+ */
+public class WaitStateMarshallerTest extends WaitStateTest
+{
+  protected ProcessDefinition getProcessDefinition() throws IOException
+  {
+    // Marshall the process to a string
+    ProcessDefinition procDef = super.getProcessDefinition();
+    String procXML = marshallProcess(procDef);
+
+    //System.out.println(procXML);
+
+    // Recreate the ProcessDefinition from the marshalled ProcessDefinition
+    ProcessDefinitionService pdService = getProcessEngine().getService(ProcessDefinitionService.class);
+    return pdService.createProcessDefinition(procXML);
+  }
+}


Property changes on: projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateMarshallerTest.java
___________________________________________________________________
Name: svn:keywords
   + Id Revision
Name: svn:eol-style
   + LF

Modified: projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateTest.java
===================================================================
--- projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateTest.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/cts/src/test/java/org/jbpm/test/cts/task/waitstate/WaitStateTest.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -75,7 +75,7 @@
     assertEquals(ProcessStatus.Completed, proc.getProcessStatus());
   }
 
-  public ProcessDefinition getProcessDefinition() throws IOException
+  protected ProcessDefinition getProcessDefinition() throws IOException
   {
     ProcessBuilder procBuilder = ProcessBuilderService.locateProcessBuilder();
     procBuilder.addProcess("Proc").addStartEvent("Start").addSequenceFlow("TaskA");

Modified: projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshaller.java
===================================================================
--- projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshaller.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshaller.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -33,6 +33,7 @@
 import org.jbpm.api.NotImplementedException;
 import org.jbpm.api.model.EndEvent;
 import org.jbpm.api.model.Event;
+import org.jbpm.api.model.ExclusiveGateway;
 import org.jbpm.api.model.Expression;
 import org.jbpm.api.model.Gateway;
 import org.jbpm.api.model.Node;
@@ -42,57 +43,18 @@
 import org.jbpm.api.model.Task;
 import org.jbpm.api.model.Event.EventDetailType;
 import org.jbpm.api.model.SequenceFlow.ConditionType;
-import org.jbpm.dialect.api10.model.JAXBAssignment;
-import org.jbpm.dialect.api10.model.JAXBComplexGateway;
 import org.jbpm.dialect.api10.model.JAXBEndEvent;
 import org.jbpm.dialect.api10.model.JAXBEvent;
 import org.jbpm.dialect.api10.model.JAXBExclusiveGateway;
-import org.jbpm.dialect.api10.model.JAXBExecutionHandler;
 import org.jbpm.dialect.api10.model.JAXBExpression;
 import org.jbpm.dialect.api10.model.JAXBFlow;
-import org.jbpm.dialect.api10.model.JAXBFlowHandler;
 import org.jbpm.dialect.api10.model.JAXBGateway;
-import org.jbpm.dialect.api10.model.JAXBGroup;
-import org.jbpm.dialect.api10.model.JAXBInclusiveGateway;
-import org.jbpm.dialect.api10.model.JAXBInputSet;
-import org.jbpm.dialect.api10.model.JAXBMessage;
-import org.jbpm.dialect.api10.model.JAXBMessageEventDetail;
-import org.jbpm.dialect.api10.model.JAXBMessageRef;
 import org.jbpm.dialect.api10.model.JAXBNode;
-import org.jbpm.dialect.api10.model.JAXBOutputSet;
-import org.jbpm.dialect.api10.model.JAXBParallelGateway;
 import org.jbpm.dialect.api10.model.JAXBProcess;
-import org.jbpm.dialect.api10.model.JAXBProperty;
 import org.jbpm.dialect.api10.model.JAXBSequenceFlow;
-import org.jbpm.dialect.api10.model.JAXBSignal;
-import org.jbpm.dialect.api10.model.JAXBSignalEventDetail;
-import org.jbpm.dialect.api10.model.JAXBSignalHandler;
 import org.jbpm.dialect.api10.model.JAXBStartEvent;
 import org.jbpm.dialect.api10.model.JAXBTask;
 import org.jbpm.dialect.api10.model.ObjectFactory;
-import org.jbpm.preview.model.Assignment;
-import org.jbpm.preview.model.ComplexGateway;
-import org.jbpm.preview.model.EndEventExt;
-import org.jbpm.preview.model.EventExt;
-import org.jbpm.preview.model.ExclusiveGateway;
-import org.jbpm.preview.model.GatewayExt;
-import org.jbpm.preview.model.Group;
-import org.jbpm.preview.model.InclusiveGateway;
-import org.jbpm.preview.model.InputSet;
-import org.jbpm.preview.model.Message;
-import org.jbpm.preview.model.NodeExt;
-import org.jbpm.preview.model.OutputSet;
-import org.jbpm.preview.model.ParallelGateway;
-import org.jbpm.preview.model.Participant;
-import org.jbpm.preview.model.Property;
-import org.jbpm.preview.model.ReceiveTask;
-import org.jbpm.preview.model.SendTask;
-import org.jbpm.preview.model.Signal;
-import org.jbpm.preview.model.StartEventExt;
-import org.jbpm.preview.model.TaskExt;
-import org.jbpm.preview.runtime.ExecutionHandler;
-import org.jbpm.preview.runtime.FlowHandler;
-import org.jbpm.preview.runtime.SignalHandler;
 
 /**
  * A JAXB marshaller for a Process
@@ -118,72 +80,37 @@
     JAXBProcess jaxbProc = new JAXBProcess();
     jaxbProc.setName(procDef.getName());
 
-    /*
-    for (Message msg : procDef.getMessages())
-    {
-      JAXBMessage jaxbMsg = adaptMessage(msg);
-      jaxbProc.getMessages().add(jaxbMsg);
-    }
-    for (Property prop : procDef.getProperties())
-    {
-      JAXBProperty jaxbProp = getJaxbProperty(prop);
-      jaxbProc.getProperties().add(jaxbProp);
-    }
-    for (Assignment ass : procDef.getAssignments())
-    {
-      JAXBAssignment jaxbAss = getJaxbAssignment(ass);
-      jaxbProc.getAssignments().add(jaxbAss);
-    }
-    for (Group grp : procDef.getGroups())
-    {
-      JAXBGroup jaxbGrp = getJaxbGroup(grp);
-      jaxbProc.getGroups().add(jaxbGrp);
-    }
-    */
-
     for (Node node : procDef.getNodes())
     {
-      NodeExt nodeExt = (NodeExt)node;
-      
       JAXBNode jaxbNode;
-      if (nodeExt instanceof Event)
+      if (node instanceof Event)
       {
-        jaxbNode = adaptEvent(jaxbProc, (EventExt)nodeExt);
+        jaxbNode = adaptEvent(jaxbProc, (Event)node);
       }
-      else if (nodeExt instanceof Task)
+      else if (node instanceof Task)
       {
-        jaxbNode = adaptTask(jaxbProc, (TaskExt)nodeExt);
+        jaxbNode = adaptTask(jaxbProc, (Task)node);
       }
-      else if (nodeExt instanceof Gateway)
+      else if (node instanceof Gateway)
       {
-        jaxbNode = adaptGateway(jaxbProc, (GatewayExt)nodeExt);
+        jaxbNode = adaptGateway(jaxbProc, (Gateway)node);
       }
       else
       {
-        throw new IllegalStateException("Unsupported flow object: " + nodeExt);
+        throw new IllegalStateException("Unsupported flow object: " + node);
       }
 
-      for (Assignment ass : nodeExt.getAssignments())
-      {
-        JAXBAssignment jaxbAss = getJaxbAssignment(ass);
-        jaxbNode.getAssignments().add(jaxbAss);
-      }
-
-      Group groupRef = nodeExt.getGroupRef();
-      if (groupRef != null)
-        jaxbNode.setGroupRef(groupRef.getName());
-      
       jaxbProc.getNodes().add(jaxbNode);
     }
     return jaxbProc;
   }
 
-  private JAXBNode adaptEvent(JAXBProcess jaxbProc, EventExt event)
+  private JAXBNode adaptEvent(JAXBProcess jaxbProc, Event event)
   {
     JAXBEvent jaxbEvent;
     if (event instanceof StartEvent)
     {
-      StartEventExt start = (StartEventExt)event;
+      StartEvent start = (StartEvent)event;
       JAXBStartEvent jaxbStart = new JAXBStartEvent();
       jaxbStart.setName(start.getName());
       jaxbStart.setOutFlow(getJAXBFlow(start.getOutFlow()));
@@ -211,10 +138,7 @@
       }
       else if (detailType == EventDetailType.Signal)
       {
-        Signal signal = start.getSignalRef();
-        JAXBSignalEventDetail jaxbTrigger = new JAXBSignalEventDetail();
-        jaxbTrigger.setSignal(new JAXBSignal(signal.getSignalType(), signal.getMessage()));
-        jaxbStart.getTrigger().add(jaxbTrigger);
+        throw new NotImplementedException("JBPM-1696", "StartTrigger Signal");
       }
       else
       {
@@ -224,7 +148,7 @@
     }
     else if (event instanceof EndEvent)
     {
-      EndEventExt end = (EndEventExt)event;
+      EndEvent end = (EndEvent)event;
       JAXBEndEvent jaxbEnd = new JAXBEndEvent();
       jaxbEnd.setName(end.getName());
 
@@ -238,11 +162,7 @@
       }
       else if (detailType == EventDetailType.Message)
       {
-        Message message = end.getMessageRef();
-        JAXBMessageRef jaxbMessageRef = adaptMessageRef(jaxbProc, message);
-        JAXBMessageEventDetail jaxbResult = new JAXBMessageEventDetail();
-        jaxbResult.setMessageRef(jaxbMessageRef);
-        jaxbEnd.getResult().add(jaxbResult);
+        throw new NotImplementedException("JBPM-1676", "EndEvent Message Result");
       }
       else if (detailType == EventDetailType.Error)
       {
@@ -275,96 +195,30 @@
     {
       throw new IllegalStateException("Unsupported Event: " + event);
     }
-    jaxbEvent.setExecutionHandler(getJAXBExecutionHandler(event, event.getExecutionHandler()));
-    jaxbEvent.setFlowHandler(getJAXBFlowHandler(event, event.getFlowHandler()));
-    jaxbEvent.setSignalHandler(getJAXBSignalHandler(event, event.getSignalHandler()));
     return jaxbEvent;
   }
 
-  private JAXBNode adaptTask(JAXBProcess jaxbProc, TaskExt task)
+  private JAXBNode adaptTask(JAXBProcess jaxbProc, Task task)
   {
     JAXBTask jaxbTask = new JAXBTask();
     jaxbTask.setTaskType(task.getTaskType());
     jaxbTask.setName(task.getName());
     jaxbTask.setOutFlow(getJAXBFlow(task.getOutFlow()));
-    jaxbTask.setExecutionHandler(getJAXBExecutionHandler(task, task.getExecutionHandler()));
-    jaxbTask.setFlowHandler(getJAXBFlowHandler(task, task.getFlowHandler()));
-    jaxbTask.setSignalHandler(getJAXBSignalHandler(task, task.getSignalHandler()));
-    for (InputSet inSet : task.getInputSets())
-    {
-      JAXBInputSet jaxbSet = new JAXBInputSet();
-      for (Property prop : inSet.getProperties())
-      {
-        JAXBProperty jaxbProp = getJaxbProperty(prop);
-        jaxbSet.getProperties().add(jaxbProp);
-      }
-      jaxbTask.getInputSets().add(jaxbSet);
-    }
-    for (OutputSet outSet : task.getOutputSets())
-    {
-      JAXBOutputSet jaxbSet = new JAXBOutputSet();
-      for (Property prop : outSet.getProperties())
-      {
-        JAXBProperty jaxbProp = getJaxbProperty(prop);
-        jaxbSet.getProperties().add(jaxbProp);
-      }
-      jaxbTask.getOutputSets().add(jaxbSet);
-    }
-    for (Property prop : task.getProperties())
-    {
-      JAXBProperty jaxbProp = getJaxbProperty(prop);
-      jaxbTask.getProperties().add(jaxbProp);
-    }
-    if (task instanceof ReceiveTask)
-    {
-      ReceiveTask recTask = (ReceiveTask)task;
-      Message messageRef = recTask.getMessageRef();
-      if (messageRef != null)
-      {
-        JAXBMessageRef jaxbMessageRef = adaptMessageRef(jaxbProc, messageRef);
-        jaxbTask.setMessageRef(jaxbMessageRef);
-      }
-    }
-    else if (task instanceof SendTask)
-    {
-      SendTask sendTask = (SendTask)task;
-      Message messageRef = sendTask.getMessageRef();
-      if (messageRef != null)
-      {
-        JAXBMessageRef jaxbMessageRef = adaptMessageRef(jaxbProc, messageRef);
-        jaxbTask.setMessageRef(jaxbMessageRef);
-      }
-    }
     return jaxbTask;
   }
 
-  private JAXBNode adaptGateway(JAXBProcess jaxbProc, GatewayExt gateway)
+  private JAXBNode adaptGateway(JAXBProcess jaxbProc, Gateway gateway)
   {
     JAXBGateway jaxbGateway;
     if (gateway instanceof ExclusiveGateway)
     {
       jaxbGateway = new JAXBExclusiveGateway();
     }
-    else if (gateway instanceof InclusiveGateway)
-    {
-      jaxbGateway = new JAXBInclusiveGateway();
-    }
-    else if (gateway instanceof ParallelGateway)
-    {
-      jaxbGateway = new JAXBParallelGateway();
-    }
-    else if (gateway instanceof ComplexGateway)
-    {
-      jaxbGateway = new JAXBComplexGateway();
-    }
     else
     {
       throw new IllegalStateException("Unsupported gateway: " + gateway);
     }
     jaxbGateway.setName(gateway.getName());
-    jaxbGateway.setExecutionHandler(getJAXBExecutionHandler(gateway, gateway.getExecutionHandler()));
-    jaxbGateway.setFlowHandler(getJAXBFlowHandler(gateway, gateway.getFlowHandler()));
-    jaxbGateway.setSignalHandler(getJAXBSignalHandler(gateway, gateway.getSignalHandler()));
     for (SequenceFlow gate : gateway.getGates())
     {
       SequenceFlow flow = gate;
@@ -373,44 +227,6 @@
     return jaxbGateway;
   }
 
-  private JAXBMessageRef adaptMessageRef(JAXBProcess jaxbProc, Message msgRef)
-  {
-    String msgName = msgRef.getName();
-    JAXBMessage jaxbMsg = jaxbProc.getMessageByName(msgName);
-    JAXBMessageRef jaxbMsgRef = new JAXBMessageRef();
-    jaxbMsgRef.setNameRef(msgName);
-
-    String fromStr = getParticipant(msgRef.getFromRef());
-    if (fromStr != null && fromStr.equals(jaxbMsg.getFromRef()) == false)
-      jaxbMsgRef.setFromRef(fromStr);
-
-    String toStr = getParticipant(msgRef.getToRef());
-    if (toStr != null && toStr.equals(jaxbMsg.getToRef()) == false)
-      jaxbMsgRef.setToRef(toStr);
-
-    return jaxbMsgRef;
-  }
-
-  @SuppressWarnings("unused")
-  private JAXBMessage adaptMessage(Message msg)
-  {
-    JAXBMessage jaxbMsg = new JAXBMessage();
-    jaxbMsg.setName(msg.getName());
-    jaxbMsg.setFromRef(getParticipant(msg.getFromRef()));
-    jaxbMsg.setToRef(getParticipant(msg.getToRef()));
-    for (Property prop : msg.getProperties())
-    {
-      JAXBProperty jaxbProp = getJaxbProperty(prop);
-      jaxbMsg.getProperties().add(jaxbProp);
-    }
-    return jaxbMsg;
-  }
-
-  private String getParticipant(Participant par)
-  {
-    return par != null ? par.getName().getCanonicalName() : null;
-  }
-
   private JAXBFlow getJAXBFlow(SequenceFlow flow)
   {
     JAXBFlow jaxb;
@@ -437,16 +253,6 @@
     return jaxb;
   }
 
-  private JAXBProperty getJaxbProperty(Property prop)
-  {
-    JAXBProperty jaxbProp = new JAXBProperty();
-    jaxbProp.setName(prop.getName());
-    jaxbProp.setValue((String)prop.getValue());
-    if (prop.isCorrelation())
-      jaxbProp.setCorrelation(prop.isCorrelation());
-    return jaxbProp;
-  }
-
   private JAXBExpression getJAXBExpression(Expression expr)
   {
     JAXBExpression jaxb = new JAXBExpression();
@@ -454,69 +260,4 @@
     jaxb.setBody(expr.getExpressionBody());
     return jaxb;
   }
-
-  private JAXBAssignment getJaxbAssignment(Assignment ass)
-  {
-    JAXBAssignment jaxbAss = new JAXBAssignment();
-    jaxbAss.setAssignTime(ass.getAssignTime());
-    jaxbAss.setFrom(getJAXBExpression(ass.getFrom()));
-    jaxbAss.setTo(ass.getTo().getName());
-    return jaxbAss;
-  }
-
-  @SuppressWarnings("unused")
-  private JAXBGroup getJaxbGroup(Group grp)
-  {
-    JAXBGroup jaxbGrp = new JAXBGroup();
-    jaxbGrp.setName(grp.getName());
-    jaxbGrp.setGroupType(grp.getGroupType());
-    for (Property prop : grp.getProperties())
-    {
-      JAXBProperty jaxbProp = getJaxbProperty(prop);
-      jaxbGrp.getProperties().add(jaxbProp);
-    }
-    return jaxbGrp;
-  }
-
-  private JAXBExecutionHandler getJAXBExecutionHandler(Node fo, ExecutionHandler handler)
-  {
-    JAXBExecutionHandler jaxb = null;
-    if (handler != null)
-    {
-      if (fo.getClass().getPackage() != handler.getClass().getPackage())
-      {
-        jaxb = new JAXBExecutionHandler();
-        jaxb.setClassName(handler.getClass().getName());
-      }
-    }
-    return jaxb;
-  }
-
-  private JAXBFlowHandler getJAXBFlowHandler(Node fo, FlowHandler handler)
-  {
-    JAXBFlowHandler jaxb = null;
-    if (handler != null)
-    {
-      if (fo.getClass().getPackage() != handler.getClass().getPackage())
-      {
-        jaxb = new JAXBFlowHandler();
-        jaxb.setClassName(handler.getClass().getName());
-      }
-    }
-    return jaxb;
-  }
-
-  private JAXBSignalHandler getJAXBSignalHandler(Node fo, SignalHandler handler)
-  {
-    JAXBSignalHandler jaxb = null;
-    if (handler != null)
-    {
-      if (fo.getClass().getPackage() != handler.getClass().getPackage())
-      {
-        jaxb = new JAXBSignalHandler();
-        jaxb.setClassName(handler.getClass().getName());
-      }
-    }
-    return jaxb;
-  }
 }

Added: projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshallerExt.java
===================================================================
--- projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshallerExt.java	                        (rev 0)
+++ projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshallerExt.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -0,0 +1,518 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jbpm.dialect.api10;
+
+// $Id$
+
+import java.io.IOException;
+import java.io.Writer;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+
+import org.jbpm.api.NotImplementedException;
+import org.jbpm.api.model.EndEvent;
+import org.jbpm.api.model.Event;
+import org.jbpm.api.model.ExclusiveGateway;
+import org.jbpm.api.model.Expression;
+import org.jbpm.api.model.Gateway;
+import org.jbpm.api.model.Node;
+import org.jbpm.api.model.SequenceFlow;
+import org.jbpm.api.model.StartEvent;
+import org.jbpm.api.model.Task;
+import org.jbpm.api.model.Event.EventDetailType;
+import org.jbpm.api.model.SequenceFlow.ConditionType;
+import org.jbpm.dialect.api10.model.JAXBAssignment;
+import org.jbpm.dialect.api10.model.JAXBComplexGateway;
+import org.jbpm.dialect.api10.model.JAXBEndEvent;
+import org.jbpm.dialect.api10.model.JAXBEvent;
+import org.jbpm.dialect.api10.model.JAXBExclusiveGateway;
+import org.jbpm.dialect.api10.model.JAXBExecutionHandler;
+import org.jbpm.dialect.api10.model.JAXBExpression;
+import org.jbpm.dialect.api10.model.JAXBFlow;
+import org.jbpm.dialect.api10.model.JAXBFlowHandler;
+import org.jbpm.dialect.api10.model.JAXBGateway;
+import org.jbpm.dialect.api10.model.JAXBGroup;
+import org.jbpm.dialect.api10.model.JAXBInclusiveGateway;
+import org.jbpm.dialect.api10.model.JAXBInputSet;
+import org.jbpm.dialect.api10.model.JAXBMessage;
+import org.jbpm.dialect.api10.model.JAXBMessageEventDetail;
+import org.jbpm.dialect.api10.model.JAXBMessageRef;
+import org.jbpm.dialect.api10.model.JAXBNode;
+import org.jbpm.dialect.api10.model.JAXBOutputSet;
+import org.jbpm.dialect.api10.model.JAXBParallelGateway;
+import org.jbpm.dialect.api10.model.JAXBProcess;
+import org.jbpm.dialect.api10.model.JAXBProperty;
+import org.jbpm.dialect.api10.model.JAXBSequenceFlow;
+import org.jbpm.dialect.api10.model.JAXBSignal;
+import org.jbpm.dialect.api10.model.JAXBSignalEventDetail;
+import org.jbpm.dialect.api10.model.JAXBSignalHandler;
+import org.jbpm.dialect.api10.model.JAXBStartEvent;
+import org.jbpm.dialect.api10.model.JAXBTask;
+import org.jbpm.dialect.api10.model.ObjectFactory;
+import org.jbpm.preview.model.Assignment;
+import org.jbpm.preview.model.ComplexGateway;
+import org.jbpm.preview.model.EndEventExt;
+import org.jbpm.preview.model.EventExt;
+import org.jbpm.preview.model.GatewayExt;
+import org.jbpm.preview.model.Group;
+import org.jbpm.preview.model.InclusiveGateway;
+import org.jbpm.preview.model.InputSet;
+import org.jbpm.preview.model.Message;
+import org.jbpm.preview.model.NodeExt;
+import org.jbpm.preview.model.OutputSet;
+import org.jbpm.preview.model.ParallelGateway;
+import org.jbpm.preview.model.Participant;
+import org.jbpm.preview.model.ProcessDefinitionExt;
+import org.jbpm.preview.model.Property;
+import org.jbpm.preview.model.ReceiveTask;
+import org.jbpm.preview.model.SendTask;
+import org.jbpm.preview.model.Signal;
+import org.jbpm.preview.model.StartEventExt;
+import org.jbpm.preview.model.TaskExt;
+import org.jbpm.preview.runtime.ExecutionHandler;
+import org.jbpm.preview.runtime.FlowHandler;
+import org.jbpm.preview.runtime.SignalHandler;
+
+/**
+ * A JAXB marshaller for a Process
+ * 
+ * @author thomas.diesler at jboss.com
+ * @since 08-Jul-2008
+ */
+public class ProcessMarshallerExt
+{
+  public void marshallProcess(ProcessDefinitionExt procDef, Writer out) throws JAXBException, IOException
+  {
+    JAXBProcess jaxbProc = adaptProcess(procDef);
+    JAXBContext jaxbContext = JAXBContext.newInstance(ObjectFactory.class);
+    Marshaller marshaller = jaxbContext.createMarshaller();
+    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
+    marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
+
+    marshaller.marshal(jaxbProc, out);
+  }
+
+  private JAXBProcess adaptProcess(ProcessDefinitionExt procDef)
+  {
+    JAXBProcess jaxbProc = new JAXBProcess();
+    jaxbProc.setName(procDef.getName());
+
+    for (Message msg : procDef.getMessages())
+    {
+      JAXBMessage jaxbMsg = adaptMessage(msg);
+      jaxbProc.getMessages().add(jaxbMsg);
+    }
+    for (Property prop : procDef.getProperties())
+    {
+      JAXBProperty jaxbProp = getJaxbProperty(prop);
+      jaxbProc.getProperties().add(jaxbProp);
+    }
+    for (Assignment ass : procDef.getAssignments())
+    {
+      JAXBAssignment jaxbAss = getJaxbAssignment(ass);
+      jaxbProc.getAssignments().add(jaxbAss);
+    }
+    for (Group grp : procDef.getGroups())
+    {
+      JAXBGroup jaxbGrp = getJaxbGroup(grp);
+      jaxbProc.getGroups().add(jaxbGrp);
+    }
+
+    for (Node node : procDef.getNodes())
+    {
+      NodeExt nodeExt = (NodeExt)node;
+      
+      JAXBNode jaxbNode;
+      if (nodeExt instanceof Event)
+      {
+        jaxbNode = adaptEvent(jaxbProc, (EventExt)nodeExt);
+      }
+      else if (nodeExt instanceof Task)
+      {
+        jaxbNode = adaptTask(jaxbProc, (TaskExt)nodeExt);
+      }
+      else if (nodeExt instanceof Gateway)
+      {
+        jaxbNode = adaptGateway(jaxbProc, (GatewayExt)nodeExt);
+      }
+      else
+      {
+        throw new IllegalStateException("Unsupported flow object: " + nodeExt);
+      }
+
+      for (Assignment ass : nodeExt.getAssignments())
+      {
+        JAXBAssignment jaxbAss = getJaxbAssignment(ass);
+        jaxbNode.getAssignments().add(jaxbAss);
+      }
+
+      Group groupRef = nodeExt.getGroupRef();
+      if (groupRef != null)
+        jaxbNode.setGroupRef(groupRef.getName());
+      
+      jaxbProc.getNodes().add(jaxbNode);
+    }
+    return jaxbProc;
+  }
+
+  private JAXBNode adaptEvent(JAXBProcess jaxbProc, EventExt event)
+  {
+    JAXBEvent jaxbEvent;
+    if (event instanceof StartEvent)
+    {
+      StartEventExt start = (StartEventExt)event;
+      JAXBStartEvent jaxbStart = new JAXBStartEvent();
+      jaxbStart.setName(start.getName());
+      jaxbStart.setOutFlow(getJAXBFlow(start.getOutFlow()));
+
+      EventDetailType detailType = start.getDetailType();
+
+      // if (start.getTriggerType().size() > 1)
+      // throw new NotImplementedException("JBPM-1660", "StartTrigger Multiple");
+
+      if (detailType == EventDetailType.None)
+      {
+        // nothing to do
+      }
+      else if (detailType == EventDetailType.Message)
+      {
+        throw new NotImplementedException("JBPM-1657", "StartTrigger Message");
+      }
+      else if (detailType == EventDetailType.Timer)
+      {
+        throw new NotImplementedException("JBPM-1658", "StartTrigger Timer");
+      }
+      else if (detailType == EventDetailType.Rule)
+      {
+        throw new NotImplementedException("JBPM-1659", "StartTrigger Conditional");
+      }
+      else if (detailType == EventDetailType.Signal)
+      {
+        Signal signal = start.getSignalRef();
+        JAXBSignalEventDetail jaxbTrigger = new JAXBSignalEventDetail();
+        jaxbTrigger.setSignal(new JAXBSignal(signal.getSignalType(), signal.getMessage()));
+        jaxbStart.getTrigger().add(jaxbTrigger);
+      }
+      else
+      {
+        throw new IllegalStateException("Unsupported start trigger: " + detailType);
+      }
+      jaxbEvent = jaxbStart;
+    }
+    else if (event instanceof EndEvent)
+    {
+      EndEventExt end = (EndEventExt)event;
+      JAXBEndEvent jaxbEnd = new JAXBEndEvent();
+      jaxbEnd.setName(end.getName());
+
+      EventDetailType detailType = end.getDetailType();
+      // if (end.getResult().size() > 1)
+      // throw new NotImplementedException("JBPM-1683", "EndEvent Multiple Result");
+
+      if (detailType == EventDetailType.None)
+      {
+        // nothing to do
+      }
+      else if (detailType == EventDetailType.Message)
+      {
+        Message message = end.getMessageRef();
+        JAXBMessageRef jaxbMessageRef = adaptMessageRef(jaxbProc, message);
+        JAXBMessageEventDetail jaxbResult = new JAXBMessageEventDetail();
+        jaxbResult.setMessageRef(jaxbMessageRef);
+        jaxbEnd.getResult().add(jaxbResult);
+      }
+      else if (detailType == EventDetailType.Error)
+      {
+        throw new NotImplementedException("JBPM-1677", "EndEvent Error Result");
+      }
+      else if (detailType == EventDetailType.Cancel)
+      {
+        throw new NotImplementedException("JBPM-1678", "EndEvent Cancel Result");
+      }
+      else if (detailType == EventDetailType.Compensation)
+      {
+        throw new NotImplementedException("JBPM-1679", "EndEvent Compensation Result");
+      }
+      else if (detailType == EventDetailType.Signal)
+      {
+        throw new NotImplementedException("JBPM-1651", "EndEvent Signal Result");
+      }
+      else if (detailType == EventDetailType.Terminate)
+      {
+        throw new NotImplementedException("JBPM-1680", "EndEvent Terminate Result");
+      }
+      else
+      {
+        throw new IllegalStateException("Unsupported end event result type: " + detailType);
+      }
+
+      jaxbEvent = jaxbEnd;
+    }
+    else
+    {
+      throw new IllegalStateException("Unsupported Event: " + event);
+    }
+    jaxbEvent.setExecutionHandler(getJAXBExecutionHandler(event, event.getExecutionHandler()));
+    jaxbEvent.setFlowHandler(getJAXBFlowHandler(event, event.getFlowHandler()));
+    jaxbEvent.setSignalHandler(getJAXBSignalHandler(event, event.getSignalHandler()));
+    return jaxbEvent;
+  }
+
+  private JAXBNode adaptTask(JAXBProcess jaxbProc, TaskExt task)
+  {
+    JAXBTask jaxbTask = new JAXBTask();
+    jaxbTask.setTaskType(task.getTaskType());
+    jaxbTask.setName(task.getName());
+    jaxbTask.setOutFlow(getJAXBFlow(task.getOutFlow()));
+    jaxbTask.setExecutionHandler(getJAXBExecutionHandler(task, task.getExecutionHandler()));
+    jaxbTask.setFlowHandler(getJAXBFlowHandler(task, task.getFlowHandler()));
+    jaxbTask.setSignalHandler(getJAXBSignalHandler(task, task.getSignalHandler()));
+    for (InputSet inSet : task.getInputSets())
+    {
+      JAXBInputSet jaxbSet = new JAXBInputSet();
+      for (Property prop : inSet.getProperties())
+      {
+        JAXBProperty jaxbProp = getJaxbProperty(prop);
+        jaxbSet.getProperties().add(jaxbProp);
+      }
+      jaxbTask.getInputSets().add(jaxbSet);
+    }
+    for (OutputSet outSet : task.getOutputSets())
+    {
+      JAXBOutputSet jaxbSet = new JAXBOutputSet();
+      for (Property prop : outSet.getProperties())
+      {
+        JAXBProperty jaxbProp = getJaxbProperty(prop);
+        jaxbSet.getProperties().add(jaxbProp);
+      }
+      jaxbTask.getOutputSets().add(jaxbSet);
+    }
+    for (Property prop : task.getProperties())
+    {
+      JAXBProperty jaxbProp = getJaxbProperty(prop);
+      jaxbTask.getProperties().add(jaxbProp);
+    }
+    if (task instanceof ReceiveTask)
+    {
+      ReceiveTask recTask = (ReceiveTask)task;
+      Message messageRef = recTask.getMessageRef();
+      if (messageRef != null)
+      {
+        JAXBMessageRef jaxbMessageRef = adaptMessageRef(jaxbProc, messageRef);
+        jaxbTask.setMessageRef(jaxbMessageRef);
+      }
+    }
+    else if (task instanceof SendTask)
+    {
+      SendTask sendTask = (SendTask)task;
+      Message messageRef = sendTask.getMessageRef();
+      if (messageRef != null)
+      {
+        JAXBMessageRef jaxbMessageRef = adaptMessageRef(jaxbProc, messageRef);
+        jaxbTask.setMessageRef(jaxbMessageRef);
+      }
+    }
+    return jaxbTask;
+  }
+
+  private JAXBNode adaptGateway(JAXBProcess jaxbProc, GatewayExt gateway)
+  {
+    JAXBGateway jaxbGateway;
+    if (gateway instanceof ExclusiveGateway)
+    {
+      jaxbGateway = new JAXBExclusiveGateway();
+    }
+    else if (gateway instanceof InclusiveGateway)
+    {
+      jaxbGateway = new JAXBInclusiveGateway();
+    }
+    else if (gateway instanceof ParallelGateway)
+    {
+      jaxbGateway = new JAXBParallelGateway();
+    }
+    else if (gateway instanceof ComplexGateway)
+    {
+      jaxbGateway = new JAXBComplexGateway();
+    }
+    else
+    {
+      throw new IllegalStateException("Unsupported gateway: " + gateway);
+    }
+    jaxbGateway.setName(gateway.getName());
+    jaxbGateway.setExecutionHandler(getJAXBExecutionHandler(gateway, gateway.getExecutionHandler()));
+    jaxbGateway.setFlowHandler(getJAXBFlowHandler(gateway, gateway.getFlowHandler()));
+    jaxbGateway.setSignalHandler(getJAXBSignalHandler(gateway, gateway.getSignalHandler()));
+    for (SequenceFlow gate : gateway.getGates())
+    {
+      SequenceFlow flow = gate;
+      jaxbGateway.getOutFlows().add(getJAXBFlow(flow));
+    }
+    return jaxbGateway;
+  }
+
+  private JAXBMessageRef adaptMessageRef(JAXBProcess jaxbProc, Message msgRef)
+  {
+    String msgName = msgRef.getName();
+    JAXBMessage jaxbMsg = jaxbProc.getMessageByName(msgName);
+    JAXBMessageRef jaxbMsgRef = new JAXBMessageRef();
+    jaxbMsgRef.setNameRef(msgName);
+
+    String fromStr = getParticipant(msgRef.getFromRef());
+    if (fromStr != null && fromStr.equals(jaxbMsg.getFromRef()) == false)
+      jaxbMsgRef.setFromRef(fromStr);
+
+    String toStr = getParticipant(msgRef.getToRef());
+    if (toStr != null && toStr.equals(jaxbMsg.getToRef()) == false)
+      jaxbMsgRef.setToRef(toStr);
+
+    return jaxbMsgRef;
+  }
+
+  private JAXBMessage adaptMessage(Message msg)
+  {
+    JAXBMessage jaxbMsg = new JAXBMessage();
+    jaxbMsg.setName(msg.getName());
+    jaxbMsg.setFromRef(getParticipant(msg.getFromRef()));
+    jaxbMsg.setToRef(getParticipant(msg.getToRef()));
+    for (Property prop : msg.getProperties())
+    {
+      JAXBProperty jaxbProp = getJaxbProperty(prop);
+      jaxbMsg.getProperties().add(jaxbProp);
+    }
+    return jaxbMsg;
+  }
+
+  private String getParticipant(Participant par)
+  {
+    return par != null ? par.getName().getCanonicalName() : null;
+  }
+
+  private JAXBFlow getJAXBFlow(SequenceFlow flow)
+  {
+    JAXBFlow jaxb;
+    if (flow instanceof SequenceFlow)
+    {
+      SequenceFlow seqFlow = (SequenceFlow)flow;
+      JAXBSequenceFlow jaxbSeq = new JAXBSequenceFlow();
+      if (seqFlow.getConditionType() == ConditionType.Expression)
+      {
+        jaxbSeq.setConditionType(seqFlow.getConditionType());
+        jaxbSeq.setCondition(getJAXBExpression(seqFlow.getConditionExpression()));
+      }
+      else if (seqFlow.getConditionType() == ConditionType.Default)
+      {
+        jaxbSeq.setConditionType(seqFlow.getConditionType());
+      }
+      jaxb = jaxbSeq;
+    }
+    else
+    {
+      throw new NotImplementedException("JBPM-1382", "Message Flow");
+    }
+    jaxb.setTargetRef(flow.getTargetRef());
+    return jaxb;
+  }
+
+  private JAXBProperty getJaxbProperty(Property prop)
+  {
+    JAXBProperty jaxbProp = new JAXBProperty();
+    jaxbProp.setName(prop.getName());
+    jaxbProp.setValue((String)prop.getValue());
+    if (prop.isCorrelation())
+      jaxbProp.setCorrelation(prop.isCorrelation());
+    return jaxbProp;
+  }
+
+  private JAXBExpression getJAXBExpression(Expression expr)
+  {
+    JAXBExpression jaxb = new JAXBExpression();
+    jaxb.setLang(expr.getExpressionLanguage());
+    jaxb.setBody(expr.getExpressionBody());
+    return jaxb;
+  }
+
+  private JAXBAssignment getJaxbAssignment(Assignment ass)
+  {
+    JAXBAssignment jaxbAss = new JAXBAssignment();
+    jaxbAss.setAssignTime(ass.getAssignTime());
+    jaxbAss.setFrom(getJAXBExpression(ass.getFrom()));
+    jaxbAss.setTo(ass.getTo().getName());
+    return jaxbAss;
+  }
+
+  private JAXBGroup getJaxbGroup(Group grp)
+  {
+    JAXBGroup jaxbGrp = new JAXBGroup();
+    jaxbGrp.setName(grp.getName());
+    jaxbGrp.setGroupType(grp.getGroupType());
+    for (Property prop : grp.getProperties())
+    {
+      JAXBProperty jaxbProp = getJaxbProperty(prop);
+      jaxbGrp.getProperties().add(jaxbProp);
+    }
+    return jaxbGrp;
+  }
+
+  private JAXBExecutionHandler getJAXBExecutionHandler(Node fo, ExecutionHandler handler)
+  {
+    JAXBExecutionHandler jaxb = null;
+    if (handler != null)
+    {
+      if (fo.getClass().getPackage() != handler.getClass().getPackage())
+      {
+        jaxb = new JAXBExecutionHandler();
+        jaxb.setClassName(handler.getClass().getName());
+      }
+    }
+    return jaxb;
+  }
+
+  private JAXBFlowHandler getJAXBFlowHandler(Node fo, FlowHandler handler)
+  {
+    JAXBFlowHandler jaxb = null;
+    if (handler != null)
+    {
+      if (fo.getClass().getPackage() != handler.getClass().getPackage())
+      {
+        jaxb = new JAXBFlowHandler();
+        jaxb.setClassName(handler.getClass().getName());
+      }
+    }
+    return jaxb;
+  }
+
+  private JAXBSignalHandler getJAXBSignalHandler(Node fo, SignalHandler handler)
+  {
+    JAXBSignalHandler jaxb = null;
+    if (handler != null)
+    {
+      if (fo.getClass().getPackage() != handler.getClass().getPackage())
+      {
+        jaxb = new JAXBSignalHandler();
+        jaxb.setClassName(handler.getClass().getName());
+      }
+    }
+    return jaxb;
+  }
+}


Property changes on: projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessMarshallerExt.java
___________________________________________________________________
Name: svn:keywords
   + Id Revision
Name: svn:eol-style
   + LF

Modified: projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshaller.java
===================================================================
--- projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshaller.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshaller.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -26,7 +26,6 @@
 import java.io.IOException;
 import java.io.Reader;
 
-import javax.management.ObjectName;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
@@ -37,9 +36,8 @@
 import org.jbpm.api.model.SequenceFlow.ConditionType;
 import org.jbpm.api.model.Task.TaskType;
 import org.jbpm.api.model.builder.GatewayBuilder;
-import org.jbpm.api.model.builder.ObjectNameFactory;
+import org.jbpm.api.model.builder.ProcessBuilder;
 import org.jbpm.api.service.ProcessBuilderService;
-import org.jbpm.dialect.api10.model.JAXBAssignment;
 import org.jbpm.dialect.api10.model.JAXBCancelEventDetail;
 import org.jbpm.dialect.api10.model.JAXBCompensationEventDetail;
 import org.jbpm.dialect.api10.model.JAXBComplexGateway;
@@ -51,38 +49,23 @@
 import org.jbpm.dialect.api10.model.JAXBExclusiveGateway;
 import org.jbpm.dialect.api10.model.JAXBExpression;
 import org.jbpm.dialect.api10.model.JAXBFlow;
-import org.jbpm.dialect.api10.model.JAXBGroup;
-import org.jbpm.dialect.api10.model.JAXBNode;
 import org.jbpm.dialect.api10.model.JAXBGateway;
-import org.jbpm.dialect.api10.model.JAXBHandler;
 import org.jbpm.dialect.api10.model.JAXBInclusiveGateway;
-import org.jbpm.dialect.api10.model.JAXBInputSet;
 import org.jbpm.dialect.api10.model.JAXBIntermediateEvent;
-import org.jbpm.dialect.api10.model.JAXBMessage;
 import org.jbpm.dialect.api10.model.JAXBMessageEventDetail;
 import org.jbpm.dialect.api10.model.JAXBMessageFlow;
-import org.jbpm.dialect.api10.model.JAXBMessageRef;
-import org.jbpm.dialect.api10.model.JAXBOutputSet;
+import org.jbpm.dialect.api10.model.JAXBNode;
 import org.jbpm.dialect.api10.model.JAXBParallelGateway;
 import org.jbpm.dialect.api10.model.JAXBProcess;
-import org.jbpm.dialect.api10.model.JAXBProperty;
 import org.jbpm.dialect.api10.model.JAXBSequenceFlow;
-import org.jbpm.dialect.api10.model.JAXBSignal;
 import org.jbpm.dialect.api10.model.JAXBSignalEventDetail;
 import org.jbpm.dialect.api10.model.JAXBStartEvent;
 import org.jbpm.dialect.api10.model.JAXBTask;
 import org.jbpm.dialect.api10.model.JAXBTerminateEventDetail;
 import org.jbpm.dialect.api10.model.JAXBTimerEventDetail;
 import org.jbpm.dialect.api10.model.ObjectFactory;
-import org.jbpm.preview.model.builder.EventBuilder;
-import org.jbpm.preview.model.builder.GroupBuilder;
-import org.jbpm.preview.model.builder.MessageBuilder;
-import org.jbpm.preview.model.builder.ProcessBuilderExt;
-import org.jbpm.preview.model.builder.TaskBuilder;
-import org.jbpm.preview.runtime.ExecutionHandler;
-import org.jbpm.preview.runtime.FlowHandler;
-import org.jbpm.preview.runtime.NodeHandler;
-import org.jbpm.preview.runtime.SignalHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * A JAXB unmarshaller for a Process
@@ -92,6 +75,9 @@
  */
 public class ProcessUnmarshaller
 {
+  // Provide logging
+  private static final Logger log = LoggerFactory.getLogger(ProcessUnmarshaller.class);
+  
   public ProcessDefinition unmarshallProcess(Reader xml) throws JAXBException, IOException
   {
     JAXBContext jaxbContext = JAXBContext.newInstance(ObjectFactory.class);
@@ -104,41 +90,13 @@
 
   private ProcessDefinition adaptProcess(JAXBProcess jaxbProc) throws IOException
   {
-    ProcessBuilderExt procBuilder = (ProcessBuilderExt)ProcessBuilderService.locateProcessBuilder();
+    ProcessBuilder procBuilder = ProcessBuilderService.locateProcessBuilder();
     procBuilder.addProcess(jaxbProc.getName());
 
-    // Process Messages
-    for (JAXBMessage jaxb : jaxbProc.getMessages())
-    {
-      MessageBuilder msgBuilder = procBuilder.addProcessMessage(jaxb.getName());
-      adaptJAXBMessage(msgBuilder, jaxb);
-    }
-    
-    // Process Properties
-    for (JAXBProperty jaxbProp : jaxbProc.getProperties())
-    {
-      procBuilder.addProcessProperty(jaxbProp.getName(), jaxbProp.getValue());
-    }
-    
-    // Process Assignments
-    for (JAXBAssignment jaxbAss : jaxbProc.getAssignments())
-    {
-      JAXBExpression jaxbFrom = jaxbAss.getFrom();
-      String jaxbTo = jaxbAss.getTo();
-      procBuilder.addProcessAssignment(jaxbAss.getAssignTime(), jaxbFrom.getLang(), jaxbFrom.getBody(), jaxbTo);
-    }
-
-    // Process Groups
-    for (JAXBGroup jaxbGrp : jaxbProc.getGroups())
-    {
-      GroupBuilder groupBuilder = procBuilder.addGroup(jaxbGrp.getGroupType(), jaxbGrp.getName());
-      for (JAXBProperty jaxbProp : jaxbGrp.getProperties())
-        groupBuilder.addProperty(jaxbProp.getName(), jaxbProp.getValue());
-    }
-
     // Process Nodes
     for (JAXBNode jaxbNode : jaxbProc.getNodes())
     {
+      log.debug("Adapt node: " + jaxbNode);
       if (jaxbNode instanceof JAXBEvent)
       {
         adaptJAXBEvent(procBuilder, jaxbProc, (JAXBEvent)jaxbNode);
@@ -155,53 +113,18 @@
       {
         throw new IllegalStateException("Unsupported flow object: " + jaxbNode);
       }
-      
-      // Node Assignments
-      for (JAXBAssignment jaxbAss : jaxbNode.getAssignments())
-      {
-        JAXBExpression jaxbFrom = jaxbAss.getFrom();
-        String jaxbTo = jaxbAss.getTo();
-        procBuilder.addNodeAssignment(jaxbAss.getAssignTime(), jaxbFrom.getLang(), jaxbFrom.getBody(), jaxbTo);
-      }
-      
-      // Group ref
-      String groupRef = jaxbNode.getGroupRef();
-      if (groupRef != null)
-        procBuilder.addGroupRef(groupRef);
     }
 
     ProcessDefinition procDef = procBuilder.getProcessDefinition();
     return procDef;
   }
 
-  private void adaptJAXBMessage(MessageBuilder msgBuilder, JAXBMessage jaxbMsg)
+  private void adaptJAXBEvent(ProcessBuilder procBuilder, JAXBProcess jaxbProc, JAXBEvent jaxbEvent)
   {
-    String fromRef = jaxbMsg.getFromRef();
-    if (fromRef != null)
-      msgBuilder.addFromRef(getObjectName(fromRef));
-    
-    String toRef = jaxbMsg.getToRef();
-    if (toRef != null)
-      msgBuilder.addToRef(getObjectName(toRef));
-    
-    for (JAXBProperty jaxbProp : jaxbMsg.getProperties())
-    {
-      boolean isCorrelation = jaxbProp.isCorrelation() != null ? jaxbProp.isCorrelation() : false;
-      msgBuilder.addProperty(jaxbProp.getName(), jaxbProp.getValue(), isCorrelation);
-    }
-  }
-
-  private ObjectName getObjectName(String objName)
-  {
-    return ObjectNameFactory.create(objName);
-  }
-
-  private void adaptJAXBEvent(ProcessBuilderExt procBuilder, JAXBProcess jaxbProc, JAXBEvent jaxbEvent)
-  {
     if (jaxbEvent instanceof JAXBStartEvent)
     {
       JAXBStartEvent jaxbStart = (JAXBStartEvent)jaxbEvent;
-      EventBuilder eventBuilder = procBuilder.addStartEventExt(jaxbStart.getName());
+      procBuilder.addStartEvent(jaxbStart.getName());
       addOutFlow(procBuilder, jaxbStart.getOutFlow());
 
       if (jaxbStart.getTrigger().size() > 1)
@@ -223,9 +146,7 @@
         }
         if (jaxbTrigger instanceof JAXBSignalEventDetail)
         {
-          JAXBSignalEventDetail jaxbSignalTrigger = (JAXBSignalEventDetail)jaxbTrigger;
-          JAXBSignal jaxbSignal = jaxbSignalTrigger.getSignal();
-          eventBuilder.addSignalRef(jaxbSignal.getType(), jaxbSignal.getMessage());
+          throw new NotImplementedException("JBPM-1696", "StartTrigger Signal");
         }
         else
         {
@@ -240,7 +161,7 @@
     else if (jaxbEvent instanceof JAXBEndEvent)
     {
       JAXBEndEvent jaxbEnd = (JAXBEndEvent)jaxbEvent;
-      EventBuilder eventBuilder = procBuilder.addEndEventExt(jaxbEnd.getName());
+      procBuilder.addEndEvent(jaxbEnd.getName());
 
       if (jaxbEnd.getResult().size() > 1)
         throw new NotImplementedException("JBPM-1683", "EndEvent Multiple Result");
@@ -249,9 +170,7 @@
       {
         if (jaxbResult instanceof JAXBMessageEventDetail)
         {
-          JAXBMessageEventDetail jaxbMessageResult = (JAXBMessageEventDetail)jaxbResult;
-          JAXBMessageRef jaxbMsg = jaxbMessageResult.getMessageRef();
-          eventBuilder.addMessageRef(jaxbMsg.getNameRef());
+          throw new NotImplementedException("JBPM-1676", "EndEvent Message Result");
         }
         else if (jaxbResult instanceof JAXBErrorEventDetail)
         {
@@ -283,52 +202,17 @@
     {
       throw new IllegalStateException("Unsupported Event: " + jaxbEvent);
     }
-    procBuilder.addExecutionHandler(loadHandler(ExecutionHandler.class, jaxbEvent.getExecutionHandler()));
-    procBuilder.addFlowHandler(loadHandler(FlowHandler.class, jaxbEvent.getFlowHandler()));
-    procBuilder.addSignalHandler(loadHandler(SignalHandler.class, jaxbEvent.getSignalHandler()));
   }
 
-  private void adaptTask(ProcessBuilderExt procBuilder, JAXBProcess jaxbProc, JAXBTask jaxbTask)
+  private void adaptTask(ProcessBuilder procBuilder, JAXBProcess jaxbProc, JAXBTask jaxbTask)
   {
     TaskType taskType = jaxbTask.getTaskType();
-    TaskBuilder taskBuilder = procBuilder.addTaskExt(jaxbTask.getName(), taskType);
+    ProcessBuilder taskBuilder = procBuilder.addTask(jaxbTask.getName(), taskType);
     addOutFlow(taskBuilder, jaxbTask.getOutFlow());
     
-    for (JAXBInputSet jaxbSet : jaxbTask.getInputSets())
-    {
-      taskBuilder.addInputSet();
-      for (JAXBProperty jaxbProp : jaxbSet.getProperties())
-        taskBuilder.addPropertyInput(jaxbProp.getName());
-    }
-    
-    for (JAXBOutputSet jaxbSet : jaxbTask.getOutputSets())
-    {
-      taskBuilder.addOutputSet();
-      for (JAXBProperty jaxbProp : jaxbSet.getProperties())
-        taskBuilder.addPropertyOutput(jaxbProp.getName(), jaxbProp.getValue());
-    }
-    
-    for (JAXBProperty jaxbProp : jaxbTask.getProperties())
-    {
-      taskBuilder.addNodeProperty(jaxbProp.getName(), jaxbProp.getValue());
-    }
-    
-    JAXBMessageRef jaxbMsgRef = jaxbTask.getMessageRef();
-    if (jaxbMsgRef != null)
-    {
-      String msgName = jaxbMsgRef.getNameRef();
-      if (taskType == TaskType.Send)
-        taskBuilder.addOutMessageRef(msgName);
-      else if (taskType == TaskType.Receive)
-        taskBuilder.addInMessageRef(msgName);
-    }
-
-    procBuilder.addExecutionHandler(loadHandler(ExecutionHandler.class, jaxbTask.getExecutionHandler()));
-    procBuilder.addFlowHandler(loadHandler(FlowHandler.class, jaxbTask.getFlowHandler()));
-    procBuilder.addSignalHandler(loadHandler(SignalHandler.class, jaxbTask.getSignalHandler()));
   }
 
-  private void adaptJAXBGateway(ProcessBuilderExt procBuilder, JAXBProcess jaxbProc, JAXBGateway jaxb)
+  private void adaptJAXBGateway(ProcessBuilder procBuilder, JAXBProcess jaxbProc, JAXBGateway jaxb)
   {
     GatewayBuilder gwBuilder;
     if (jaxb instanceof JAXBExclusiveGateway)
@@ -379,12 +263,9 @@
         throw new IllegalStateException("Unsupported connectiong object: " + jaxbFlow);
       }
     }
-    procBuilder.addExecutionHandler(loadHandler(ExecutionHandler.class, jaxb.getExecutionHandler()));
-    procBuilder.addFlowHandler(loadHandler(FlowHandler.class, jaxb.getFlowHandler()));
-    procBuilder.addSignalHandler(loadHandler(SignalHandler.class, jaxb.getSignalHandler()));
   }
 
-  private void addOutFlow(ProcessBuilderExt procBuilder, JAXBFlow jaxbFlow)
+  private void addOutFlow(ProcessBuilder procBuilder, JAXBFlow jaxbFlow)
   {
     if (jaxbFlow != null)
     {
@@ -402,24 +283,4 @@
       }
     }
   }
-
-  @SuppressWarnings("unchecked")
-  private <T extends NodeHandler> Class<T> loadHandler(Class<T> clazz, JAXBHandler jaxbHandler)
-  {
-    Class<T> handlerClass = null;
-    if (jaxbHandler != null)
-    {
-      String className = jaxbHandler.getClassName();
-      try
-      {
-        ClassLoader ctxLoader = Thread.currentThread().getContextClassLoader();
-        handlerClass = (Class<T>)ctxLoader.loadClass(className);
-      }
-      catch (ClassNotFoundException e)
-      {
-        throw new IllegalStateException("Cannot load handler class: " + className);
-      }
-    }
-    return handlerClass;
-  }
 }

Added: projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshallerExt.java
===================================================================
--- projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshallerExt.java	                        (rev 0)
+++ projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshallerExt.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -0,0 +1,425 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jbpm.dialect.api10;
+
+// $Id$
+
+import java.io.IOException;
+import java.io.Reader;
+
+import javax.management.ObjectName;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+
+import org.jbpm.api.NotImplementedException;
+import org.jbpm.api.model.Gateway;
+import org.jbpm.api.model.ProcessDefinition;
+import org.jbpm.api.model.SequenceFlow.ConditionType;
+import org.jbpm.api.model.Task.TaskType;
+import org.jbpm.api.model.builder.GatewayBuilder;
+import org.jbpm.api.model.builder.ObjectNameFactory;
+import org.jbpm.api.service.ProcessBuilderService;
+import org.jbpm.dialect.api10.model.JAXBAssignment;
+import org.jbpm.dialect.api10.model.JAXBCancelEventDetail;
+import org.jbpm.dialect.api10.model.JAXBCompensationEventDetail;
+import org.jbpm.dialect.api10.model.JAXBComplexGateway;
+import org.jbpm.dialect.api10.model.JAXBConditionalEventDetail;
+import org.jbpm.dialect.api10.model.JAXBEndEvent;
+import org.jbpm.dialect.api10.model.JAXBErrorEventDetail;
+import org.jbpm.dialect.api10.model.JAXBEvent;
+import org.jbpm.dialect.api10.model.JAXBEventDetail;
+import org.jbpm.dialect.api10.model.JAXBExclusiveGateway;
+import org.jbpm.dialect.api10.model.JAXBExpression;
+import org.jbpm.dialect.api10.model.JAXBFlow;
+import org.jbpm.dialect.api10.model.JAXBGroup;
+import org.jbpm.dialect.api10.model.JAXBNode;
+import org.jbpm.dialect.api10.model.JAXBGateway;
+import org.jbpm.dialect.api10.model.JAXBHandler;
+import org.jbpm.dialect.api10.model.JAXBInclusiveGateway;
+import org.jbpm.dialect.api10.model.JAXBInputSet;
+import org.jbpm.dialect.api10.model.JAXBIntermediateEvent;
+import org.jbpm.dialect.api10.model.JAXBMessage;
+import org.jbpm.dialect.api10.model.JAXBMessageEventDetail;
+import org.jbpm.dialect.api10.model.JAXBMessageFlow;
+import org.jbpm.dialect.api10.model.JAXBMessageRef;
+import org.jbpm.dialect.api10.model.JAXBOutputSet;
+import org.jbpm.dialect.api10.model.JAXBParallelGateway;
+import org.jbpm.dialect.api10.model.JAXBProcess;
+import org.jbpm.dialect.api10.model.JAXBProperty;
+import org.jbpm.dialect.api10.model.JAXBSequenceFlow;
+import org.jbpm.dialect.api10.model.JAXBSignal;
+import org.jbpm.dialect.api10.model.JAXBSignalEventDetail;
+import org.jbpm.dialect.api10.model.JAXBStartEvent;
+import org.jbpm.dialect.api10.model.JAXBTask;
+import org.jbpm.dialect.api10.model.JAXBTerminateEventDetail;
+import org.jbpm.dialect.api10.model.JAXBTimerEventDetail;
+import org.jbpm.dialect.api10.model.ObjectFactory;
+import org.jbpm.preview.model.builder.EventBuilder;
+import org.jbpm.preview.model.builder.GroupBuilder;
+import org.jbpm.preview.model.builder.MessageBuilder;
+import org.jbpm.preview.model.builder.ProcessBuilderExt;
+import org.jbpm.preview.model.builder.TaskBuilder;
+import org.jbpm.preview.runtime.ExecutionHandler;
+import org.jbpm.preview.runtime.FlowHandler;
+import org.jbpm.preview.runtime.NodeHandler;
+import org.jbpm.preview.runtime.SignalHandler;
+
+/**
+ * A JAXB unmarshaller for a Process
+ * 
+ * @author thomas.diesler at jboss.com
+ * @since 08-Jul-2008
+ */
+public class ProcessUnmarshallerExt
+{
+  public ProcessDefinition unmarshallProcess(Reader xml) throws JAXBException, IOException
+  {
+    JAXBContext jaxbContext = JAXBContext.newInstance(ObjectFactory.class);
+    Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
+    unmarshaller.setProperty("com.sun.xml.bind.ObjectFactory", new ObjectFactory());
+    JAXBProcess jaxbProc = (JAXBProcess)unmarshaller.unmarshal(xml);
+    ProcessDefinition procDef = adaptProcess(jaxbProc);
+    return procDef;
+  }
+
+  private ProcessDefinition adaptProcess(JAXBProcess jaxbProc) throws IOException
+  {
+    ProcessBuilderExt procBuilder = (ProcessBuilderExt)ProcessBuilderService.locateProcessBuilder();
+    procBuilder.addProcess(jaxbProc.getName());
+
+    // Process Messages
+    for (JAXBMessage jaxb : jaxbProc.getMessages())
+    {
+      MessageBuilder msgBuilder = procBuilder.addProcessMessage(jaxb.getName());
+      adaptJAXBMessage(msgBuilder, jaxb);
+    }
+    
+    // Process Properties
+    for (JAXBProperty jaxbProp : jaxbProc.getProperties())
+    {
+      procBuilder.addProcessProperty(jaxbProp.getName(), jaxbProp.getValue());
+    }
+    
+    // Process Assignments
+    for (JAXBAssignment jaxbAss : jaxbProc.getAssignments())
+    {
+      JAXBExpression jaxbFrom = jaxbAss.getFrom();
+      String jaxbTo = jaxbAss.getTo();
+      procBuilder.addProcessAssignment(jaxbAss.getAssignTime(), jaxbFrom.getLang(), jaxbFrom.getBody(), jaxbTo);
+    }
+
+    // Process Groups
+    for (JAXBGroup jaxbGrp : jaxbProc.getGroups())
+    {
+      GroupBuilder groupBuilder = procBuilder.addGroup(jaxbGrp.getGroupType(), jaxbGrp.getName());
+      for (JAXBProperty jaxbProp : jaxbGrp.getProperties())
+        groupBuilder.addProperty(jaxbProp.getName(), jaxbProp.getValue());
+    }
+
+    // Process Nodes
+    for (JAXBNode jaxbNode : jaxbProc.getNodes())
+    {
+      if (jaxbNode instanceof JAXBEvent)
+      {
+        adaptJAXBEvent(procBuilder, jaxbProc, (JAXBEvent)jaxbNode);
+      }
+      else if (jaxbNode instanceof JAXBTask)
+      {
+        adaptTask(procBuilder, jaxbProc, (JAXBTask)jaxbNode);
+      }
+      else if (jaxbNode instanceof JAXBGateway)
+      {
+        adaptJAXBGateway(procBuilder, jaxbProc, (JAXBGateway)jaxbNode);
+      }
+      else
+      {
+        throw new IllegalStateException("Unsupported flow object: " + jaxbNode);
+      }
+      
+      // Node Assignments
+      for (JAXBAssignment jaxbAss : jaxbNode.getAssignments())
+      {
+        JAXBExpression jaxbFrom = jaxbAss.getFrom();
+        String jaxbTo = jaxbAss.getTo();
+        procBuilder.addNodeAssignment(jaxbAss.getAssignTime(), jaxbFrom.getLang(), jaxbFrom.getBody(), jaxbTo);
+      }
+      
+      // Group ref
+      String groupRef = jaxbNode.getGroupRef();
+      if (groupRef != null)
+        procBuilder.addGroupRef(groupRef);
+    }
+
+    ProcessDefinition procDef = procBuilder.getProcessDefinition();
+    return procDef;
+  }
+
+  private void adaptJAXBMessage(MessageBuilder msgBuilder, JAXBMessage jaxbMsg)
+  {
+    String fromRef = jaxbMsg.getFromRef();
+    if (fromRef != null)
+      msgBuilder.addFromRef(getObjectName(fromRef));
+    
+    String toRef = jaxbMsg.getToRef();
+    if (toRef != null)
+      msgBuilder.addToRef(getObjectName(toRef));
+    
+    for (JAXBProperty jaxbProp : jaxbMsg.getProperties())
+    {
+      boolean isCorrelation = jaxbProp.isCorrelation() != null ? jaxbProp.isCorrelation() : false;
+      msgBuilder.addProperty(jaxbProp.getName(), jaxbProp.getValue(), isCorrelation);
+    }
+  }
+
+  private ObjectName getObjectName(String objName)
+  {
+    return ObjectNameFactory.create(objName);
+  }
+
+  private void adaptJAXBEvent(ProcessBuilderExt procBuilder, JAXBProcess jaxbProc, JAXBEvent jaxbEvent)
+  {
+    if (jaxbEvent instanceof JAXBStartEvent)
+    {
+      JAXBStartEvent jaxbStart = (JAXBStartEvent)jaxbEvent;
+      EventBuilder eventBuilder = procBuilder.addStartEventExt(jaxbStart.getName());
+      addOutFlow(procBuilder, jaxbStart.getOutFlow());
+
+      if (jaxbStart.getTrigger().size() > 1)
+        throw new NotImplementedException("JBPM-1660", "StartTrigger Multiple");
+
+      for (JAXBEventDetail jaxbTrigger : jaxbStart.getTrigger())
+      {
+        if (jaxbTrigger instanceof JAXBMessageEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1657", "StartTrigger Message");
+        }
+        if (jaxbTrigger instanceof JAXBTimerEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1658", "StartTrigger Timer");
+        }
+        if (jaxbTrigger instanceof JAXBConditionalEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1659", "StartTrigger Conditional");
+        }
+        if (jaxbTrigger instanceof JAXBSignalEventDetail)
+        {
+          JAXBSignalEventDetail jaxbSignalTrigger = (JAXBSignalEventDetail)jaxbTrigger;
+          JAXBSignal jaxbSignal = jaxbSignalTrigger.getSignal();
+          eventBuilder.addSignalRef(jaxbSignal.getType(), jaxbSignal.getMessage());
+        }
+        else
+        {
+          throw new IllegalStateException("Unsupported start trigger: " + jaxbTrigger);
+        }
+      }
+    }
+    else if (jaxbEvent instanceof JAXBIntermediateEvent)
+    {
+      throw new NotImplementedException("JBPM-1661", "IntermediateEvent");
+    }
+    else if (jaxbEvent instanceof JAXBEndEvent)
+    {
+      JAXBEndEvent jaxbEnd = (JAXBEndEvent)jaxbEvent;
+      EventBuilder eventBuilder = procBuilder.addEndEventExt(jaxbEnd.getName());
+
+      if (jaxbEnd.getResult().size() > 1)
+        throw new NotImplementedException("JBPM-1683", "EndEvent Multiple Result");
+
+      for (JAXBEventDetail jaxbResult : jaxbEnd.getResult())
+      {
+        if (jaxbResult instanceof JAXBMessageEventDetail)
+        {
+          JAXBMessageEventDetail jaxbMessageResult = (JAXBMessageEventDetail)jaxbResult;
+          JAXBMessageRef jaxbMsg = jaxbMessageResult.getMessageRef();
+          eventBuilder.addMessageRef(jaxbMsg.getNameRef());
+        }
+        else if (jaxbResult instanceof JAXBErrorEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1677", "EndEvent Error Result");
+        }
+        else if (jaxbResult instanceof JAXBCancelEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1678", "EndEvent Cancel Result");
+        }
+        else if (jaxbResult instanceof JAXBCompensationEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1679", "EndEvent Compensation Result");
+        }
+        else if (jaxbResult instanceof JAXBSignalEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1651", "EndEvent Signal Result");
+        }
+        else if (jaxbResult instanceof JAXBTerminateEventDetail)
+        {
+          throw new NotImplementedException("JBPM-1680", "EndEvent Terminate Result");
+        }
+        else
+        {
+          throw new IllegalStateException("Unsupported end event result type: " + jaxbResult);
+        }
+      }
+    }
+    else
+    {
+      throw new IllegalStateException("Unsupported Event: " + jaxbEvent);
+    }
+    procBuilder.addExecutionHandler(loadHandler(ExecutionHandler.class, jaxbEvent.getExecutionHandler()));
+    procBuilder.addFlowHandler(loadHandler(FlowHandler.class, jaxbEvent.getFlowHandler()));
+    procBuilder.addSignalHandler(loadHandler(SignalHandler.class, jaxbEvent.getSignalHandler()));
+  }
+
+  private void adaptTask(ProcessBuilderExt procBuilder, JAXBProcess jaxbProc, JAXBTask jaxbTask)
+  {
+    TaskType taskType = jaxbTask.getTaskType();
+    TaskBuilder taskBuilder = procBuilder.addTaskExt(jaxbTask.getName(), taskType);
+    addOutFlow(taskBuilder, jaxbTask.getOutFlow());
+    
+    for (JAXBInputSet jaxbSet : jaxbTask.getInputSets())
+    {
+      taskBuilder.addInputSet();
+      for (JAXBProperty jaxbProp : jaxbSet.getProperties())
+        taskBuilder.addPropertyInput(jaxbProp.getName());
+    }
+    
+    for (JAXBOutputSet jaxbSet : jaxbTask.getOutputSets())
+    {
+      taskBuilder.addOutputSet();
+      for (JAXBProperty jaxbProp : jaxbSet.getProperties())
+        taskBuilder.addPropertyOutput(jaxbProp.getName(), jaxbProp.getValue());
+    }
+    
+    for (JAXBProperty jaxbProp : jaxbTask.getProperties())
+    {
+      taskBuilder.addNodeProperty(jaxbProp.getName(), jaxbProp.getValue());
+    }
+    
+    JAXBMessageRef jaxbMsgRef = jaxbTask.getMessageRef();
+    if (jaxbMsgRef != null)
+    {
+      String msgName = jaxbMsgRef.getNameRef();
+      if (taskType == TaskType.Send)
+        taskBuilder.addOutMessageRef(msgName);
+      else if (taskType == TaskType.Receive)
+        taskBuilder.addInMessageRef(msgName);
+    }
+
+    procBuilder.addExecutionHandler(loadHandler(ExecutionHandler.class, jaxbTask.getExecutionHandler()));
+    procBuilder.addFlowHandler(loadHandler(FlowHandler.class, jaxbTask.getFlowHandler()));
+    procBuilder.addSignalHandler(loadHandler(SignalHandler.class, jaxbTask.getSignalHandler()));
+  }
+
+  private void adaptJAXBGateway(ProcessBuilderExt procBuilder, JAXBProcess jaxbProc, JAXBGateway jaxb)
+  {
+    GatewayBuilder gwBuilder;
+    if (jaxb instanceof JAXBExclusiveGateway)
+    {
+      gwBuilder = procBuilder.addGateway(jaxb.getName(), Gateway.GatewayType.Exclusive);
+    }
+    else if (jaxb instanceof JAXBInclusiveGateway)
+    {
+      gwBuilder = procBuilder.addGateway(jaxb.getName(), Gateway.GatewayType.Inclusive);
+    }
+    else if (jaxb instanceof JAXBComplexGateway)
+    {
+      gwBuilder = procBuilder.addGateway(jaxb.getName(), Gateway.GatewayType.Complex);
+    }
+    else if (jaxb instanceof JAXBParallelGateway)
+    {
+      gwBuilder = procBuilder.addGateway(jaxb.getName(), Gateway.GatewayType.Parallel);
+    }
+    else
+    {
+      throw new IllegalStateException("Unsupported gateway: " + jaxb);
+    }
+    for (JAXBFlow jaxbFlow : jaxb.getOutFlows())
+    {
+      if (jaxbFlow instanceof JAXBSequenceFlow)
+      {
+        JAXBSequenceFlow jaxbSeq = (JAXBSequenceFlow)jaxbFlow;
+        if (jaxbSeq.getConditionType() == ConditionType.Expression)
+        {
+          JAXBExpression jaxbExpr = jaxbSeq.getCondition();
+          gwBuilder.addConditionalGate(jaxbFlow.getTargetRef(), jaxbExpr.getLang(), jaxbExpr.getBody());
+        }
+        else if (jaxbSeq.getConditionType() == ConditionType.Default)
+        {
+          gwBuilder.addDefaultGate(jaxbFlow.getTargetRef());
+        }
+        else
+        {
+          gwBuilder.addGate(jaxbFlow.getTargetRef());
+        }
+      }
+      else if (jaxbFlow instanceof JAXBMessageFlow)
+      {
+        throw new NotImplementedException("JBPM-1382", "Message Flow");
+      }
+      else
+      {
+        throw new IllegalStateException("Unsupported connectiong object: " + jaxbFlow);
+      }
+    }
+    procBuilder.addExecutionHandler(loadHandler(ExecutionHandler.class, jaxb.getExecutionHandler()));
+    procBuilder.addFlowHandler(loadHandler(FlowHandler.class, jaxb.getFlowHandler()));
+    procBuilder.addSignalHandler(loadHandler(SignalHandler.class, jaxb.getSignalHandler()));
+  }
+
+  private void addOutFlow(ProcessBuilderExt procBuilder, JAXBFlow jaxbFlow)
+  {
+    if (jaxbFlow != null)
+    {
+      if (jaxbFlow instanceof JAXBSequenceFlow)
+      {
+        procBuilder.addSequenceFlow(jaxbFlow.getTargetRef());
+      }
+      else if (jaxbFlow instanceof JAXBMessageFlow)
+      {
+        throw new NotImplementedException("JBPM-1382", "Message Flow");
+      }
+      else
+      {
+        throw new IllegalStateException("Unsupported connectiong object: " + jaxbFlow);
+      }
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private <T extends NodeHandler> Class<T> loadHandler(Class<T> clazz, JAXBHandler jaxbHandler)
+  {
+    Class<T> handlerClass = null;
+    if (jaxbHandler != null)
+    {
+      String className = jaxbHandler.getClassName();
+      try
+      {
+        ClassLoader ctxLoader = Thread.currentThread().getContextClassLoader();
+        handlerClass = (Class<T>)ctxLoader.loadClass(className);
+      }
+      catch (ClassNotFoundException e)
+      {
+        throw new IllegalStateException("Cannot load handler class: " + className);
+      }
+    }
+    return handlerClass;
+  }
+}


Property changes on: projects/spec/trunk/modules/dialects/api10/src/main/java/org/jbpm/dialect/api10/ProcessUnmarshallerExt.java
___________________________________________________________________
Name: svn:keywords
   + Id Revision
Name: svn:eol-style
   + LF

Modified: projects/spec/trunk/modules/ri/src/main/java/org/jbpm/ri/model/ExclusiveGatewayImpl.java
===================================================================
--- projects/spec/trunk/modules/ri/src/main/java/org/jbpm/ri/model/ExclusiveGatewayImpl.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/ri/src/main/java/org/jbpm/ri/model/ExclusiveGatewayImpl.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -30,12 +30,12 @@
 import javax.persistence.Transient;
 
 import org.jbpm.api.client.Token;
+import org.jbpm.api.model.ExclusiveGateway;
 import org.jbpm.api.model.Expression;
 import org.jbpm.api.model.Node;
 import org.jbpm.api.model.ProcessStructure;
 import org.jbpm.api.model.SequenceFlow;
 import org.jbpm.api.model.SequenceFlow.ConditionType;
-import org.jbpm.preview.model.ExclusiveGateway;
 import org.jbpm.preview.runtime.ExecutionHandler;
 import org.jbpm.preview.runtime.FlowHandler;
 import org.jbpm.preview.runtime.TokenExecutor;

Modified: projects/spec/trunk/modules/ri/src/test/java/org/jbpm/test/ri/service/persistence/ExclusiveGatewayPersistenceTest.java
===================================================================
--- projects/spec/trunk/modules/ri/src/test/java/org/jbpm/test/ri/service/persistence/ExclusiveGatewayPersistenceTest.java	2008-11-14 11:13:30 UTC (rev 2926)
+++ projects/spec/trunk/modules/ri/src/test/java/org/jbpm/test/ri/service/persistence/ExclusiveGatewayPersistenceTest.java	2008-11-14 11:59:25 UTC (rev 2927)
@@ -25,8 +25,8 @@
 
 import javax.management.ObjectName;
 
+import org.jbpm.api.model.ExclusiveGateway;
 import org.jbpm.api.model.Gateway.GatewayType;
-import org.jbpm.preview.model.ExclusiveGateway;
 import org.jbpm.ri.model.ExclusiveGatewayImpl;
 
 /**




More information about the jbpm-commits mailing list