This is an automated email from the ASF dual-hosted git repository.
egonzalez pushed a commit to branch main
in repository
https://gitbox.apache.org/repos/asf/incubator-kie-kogito-runtimes.git
The following commit(s) were added to refs/heads/main by this push:
new b850445eb1 [incubator-kie-issues-1109] Add capability to extends the
flow builder (#3497)
b850445eb1 is described below
commit b850445eb16423a8689405d912f3d74614274a05
Author: Enrique <[email protected]>
AuthorDate: Mon May 13 08:56:35 2024 +0200
[incubator-kie-issues-1109] Add capability to extends the flow builder
(#3497)
This allows includes new nodes dynamically
---
.../core/RuleFlowNodeContainerFactory.java | 88 +++++++++++++++-------
.../jbpm/ruleflow/core/RuleFlowProcessFactory.java | 9 ++-
.../core/factory/AbstractCompositeNodeFactory.java | 7 +-
.../ruleflow/core/factory/ActionNodeFactory.java | 1 +
.../ruleflow/core/factory/DynamicNodeFactory.java | 1 +
.../ruleflow/core/factory/ExtendedNodeFactory.java | 23 ++++++
.../jbpm/ruleflow/core/factory/NodeFactory.java | 28 -------
.../ActionNodeFactoryProvider.java} | 21 +++---
.../BoundaryEventNodeFactoryProvider.java} | 21 +++---
.../CatchLinkNodeFactoryProvider.java} | 19 +++--
.../CompositeContextNodeFactoryProvider.java} | 19 +++--
.../DynamicNodeFactoryProvider.java} | 19 +++--
.../EndNodeFactoryProvider.java} | 19 +++--
.../EventNodeFactoryProvider.java} | 19 +++--
.../EventSubProcessNodeFactoryProvider.java} | 19 +++--
.../FaultNodeFactoryProvider.java} | 19 +++--
.../ForEachNodeFactoryProvider.java} | 19 +++--
.../HumanTaskNodeFactoryProvider.java} | 19 +++--
.../JoinNodeFactoryProvider.java} | 19 +++--
.../MilestoneNodeFactoryProvider.java} | 19 +++--
.../NodeFactoryProvider.java} | 15 ++--
.../provider/NodeFactoryProviderService.java | 50 ++++++++++++
.../RuleSetNodeFactoryProvider.java} | 19 +++--
.../SplitNodeFactoryProvider.java} | 19 +++--
.../StartNodeFactoryProvider.java} | 19 +++--
.../StateNodeFactoryProvider.java} | 19 +++--
.../SubProcessNodeFactoryProvider.java} | 19 +++--
.../ThrowLinkNodeFactoryProvider.java} | 20 +++--
.../TimerNodeFactoryProvider.java} | 19 +++--
.../WorkItemNodeFactoryProvider.java} | 19 +++--
...eflow.core.factory.provider.NodeFactoryProvider | 21 ++++++
.../{examples.model => examples/model}/Movie.java | 0
.../model}/MovieGenre.java | 0
.../{examples.model => examples/model}/Rating.java | 0
.../integrationtests/VersionRestController.java | 2 +-
35 files changed, 407 insertions(+), 242 deletions(-)
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowNodeContainerFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowNodeContainerFactory.java
index 66c1e2e16d..8dbdc4769c 100755
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowNodeContainerFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowNodeContainerFactory.java
@@ -34,6 +34,7 @@ import org.jbpm.ruleflow.core.factory.DynamicNodeFactory;
import org.jbpm.ruleflow.core.factory.EndNodeFactory;
import org.jbpm.ruleflow.core.factory.EventNodeFactory;
import org.jbpm.ruleflow.core.factory.EventSubProcessNodeFactory;
+import org.jbpm.ruleflow.core.factory.ExtendedNodeFactory;
import org.jbpm.ruleflow.core.factory.FaultNodeFactory;
import org.jbpm.ruleflow.core.factory.ForEachNodeFactory;
import org.jbpm.ruleflow.core.factory.HumanTaskNodeFactory;
@@ -48,10 +49,32 @@ import org.jbpm.ruleflow.core.factory.SubProcessNodeFactory;
import org.jbpm.ruleflow.core.factory.ThrowLinkNodeFactory;
import org.jbpm.ruleflow.core.factory.TimerNodeFactory;
import org.jbpm.ruleflow.core.factory.WorkItemNodeFactory;
+import org.jbpm.ruleflow.core.factory.provider.NodeFactoryProviderService;
import org.jbpm.workflow.core.Connection;
import org.jbpm.workflow.core.NodeContainer;
import org.jbpm.workflow.core.impl.ConnectionImpl;
import org.jbpm.workflow.core.impl.DroolsConsequenceAction;
+import org.jbpm.workflow.core.node.ActionNode;
+import org.jbpm.workflow.core.node.BoundaryEventNode;
+import org.jbpm.workflow.core.node.CatchLinkNode;
+import org.jbpm.workflow.core.node.CompositeContextNode;
+import org.jbpm.workflow.core.node.DynamicNode;
+import org.jbpm.workflow.core.node.EndNode;
+import org.jbpm.workflow.core.node.EventNode;
+import org.jbpm.workflow.core.node.EventSubProcessNode;
+import org.jbpm.workflow.core.node.FaultNode;
+import org.jbpm.workflow.core.node.ForEachNode;
+import org.jbpm.workflow.core.node.HumanTaskNode;
+import org.jbpm.workflow.core.node.Join;
+import org.jbpm.workflow.core.node.MilestoneNode;
+import org.jbpm.workflow.core.node.RuleSetNode;
+import org.jbpm.workflow.core.node.Split;
+import org.jbpm.workflow.core.node.StartNode;
+import org.jbpm.workflow.core.node.StateNode;
+import org.jbpm.workflow.core.node.SubProcessNode;
+import org.jbpm.workflow.core.node.ThrowLinkNode;
+import org.jbpm.workflow.core.node.TimerNode;
+import org.jbpm.workflow.core.node.WorkItemNode;
import org.kie.api.definition.process.Node;
import org.kie.api.definition.process.WorkflowElementIdentifier;
@@ -60,97 +83,106 @@ import static org.jbpm.ruleflow.core.Metadata.HIDDEN;
import static org.jbpm.ruleflow.core.Metadata.UNIQUE_ID;
import static org.jbpm.workflow.core.Node.CONNECTION_DEFAULT_TYPE;
-public abstract class RuleFlowNodeContainerFactory<T extends
RuleFlowNodeContainerFactory<T, P>, P extends RuleFlowNodeContainerFactory<P,
?>> extends NodeFactory<T, P> {
+public abstract class RuleFlowNodeContainerFactory<T extends
RuleFlowNodeContainerFactory<T, P>, P extends RuleFlowNodeContainerFactory<P,
?>> extends ExtendedNodeFactory<T, P> {
public static final String METHOD_CONNECTION = "connection";
public static final String METHOD_ASSOCIATION = "association";
- protected RuleFlowNodeContainerFactory(P nodeContainerFactory,
NodeContainer nodeContainer, NodeContainer node, WorkflowElementIdentifier id) {
+ private NodeFactoryProviderService provider;
+
+ public RuleFlowNodeContainerFactory(P nodeContainerFactory, NodeContainer
nodeContainer, org.jbpm.workflow.core.Node node, WorkflowElementIdentifier id) {
super(nodeContainerFactory, nodeContainer, node, id);
+ provider = new NodeFactoryProviderService();
+ }
+
+ protected abstract NodeContainer getNodeContainer();
+
+ public <R extends NodeFactory<R, T>> R newNode(Class<?> node,
WorkflowElementIdentifier id) {
+ return provider.newNodeFactory(node, (T) this, getNodeContainer(), id);
}
public StartNodeFactory<T> startNode(WorkflowElementIdentifier id) {
- return new StartNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(StartNode.class, id);
}
public EndNodeFactory<T> endNode(WorkflowElementIdentifier id) {
- return new EndNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(EndNode.class, id);
}
public CatchLinkNodeFactory<T> catchLinkNode(WorkflowElementIdentifier id)
{
- return new CatchLinkNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(CatchLinkNode.class, id);
}
public ThrowLinkNodeFactory<T> throwLinkNode(WorkflowElementIdentifier id)
{
- return new ThrowLinkNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(ThrowLinkNode.class, id);
}
public ActionNodeFactory<T> actionNode(WorkflowElementIdentifier id) {
- return new ActionNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(ActionNode.class, id);
}
public MilestoneNodeFactory<T> milestoneNode(WorkflowElementIdentifier id)
{
- return new MilestoneNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(MilestoneNode.class, id);
}
public TimerNodeFactory<T> timerNode(WorkflowElementIdentifier id) {
- return new TimerNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(TimerNode.class, id);
}
public HumanTaskNodeFactory<T> humanTaskNode(WorkflowElementIdentifier id)
{
- return new HumanTaskNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(HumanTaskNode.class, id);
}
public SubProcessNodeFactory<T> subProcessNode(WorkflowElementIdentifier
id) {
- return new SubProcessNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(SubProcessNode.class, id);
}
public SplitFactory<T> splitNode(WorkflowElementIdentifier id) {
- return new SplitFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(Split.class, id);
}
public JoinFactory<T> joinNode(WorkflowElementIdentifier id) {
- return new JoinFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(Join.class, id);
}
public RuleSetNodeFactory<T> ruleSetNode(WorkflowElementIdentifier id) {
- return new RuleSetNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(RuleSetNode.class, id);
}
public FaultNodeFactory<T> faultNode(WorkflowElementIdentifier id) {
- return new FaultNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(FaultNode.class, id);
}
public EventNodeFactory<T> eventNode(WorkflowElementIdentifier id) {
- return new EventNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(EventNode.class, id);
}
public BoundaryEventNodeFactory<T>
boundaryEventNode(WorkflowElementIdentifier id) {
- return new BoundaryEventNodeFactory<>((T) this, (NodeContainer) node,
id);
+ return newNode(BoundaryEventNode.class, id);
}
public CompositeContextNodeFactory<T>
compositeContextNode(WorkflowElementIdentifier id) {
- return new CompositeContextNodeFactory<>((T) this, (NodeContainer)
node, id);
+ return newNode(CompositeContextNode.class, id);
}
public ForEachNodeFactory<T> forEachNode(WorkflowElementIdentifier id) {
- return new ForEachNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(ForEachNode.class, id);
}
public DynamicNodeFactory<T> dynamicNode(WorkflowElementIdentifier id) {
- return new DynamicNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(DynamicNode.class, id);
}
public WorkItemNodeFactory<T> workItemNode(WorkflowElementIdentifier id) {
- return new WorkItemNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(WorkItemNode.class, id);
}
public EventSubProcessNodeFactory<T>
eventSubProcessNode(WorkflowElementIdentifier id) {
- return new EventSubProcessNodeFactory<>((T) this, (NodeContainer)
node, id);
+ return newNode(EventSubProcessNode.class, id);
}
public StateNodeFactory<T> stateNode(WorkflowElementIdentifier id) {
- return new StateNodeFactory<>((T) this, (NodeContainer) node, id);
+ return newNode(StateNode.class, id);
}
public T connection(WorkflowElementIdentifier fromId,
WorkflowElementIdentifier toId) {
@@ -170,8 +202,8 @@ public abstract class RuleFlowNodeContainerFactory<T
extends RuleFlowNodeContain
}
private Connection getConnection(WorkflowElementIdentifier fromId,
WorkflowElementIdentifier toId, String uniqueId) {
- Node from = ((NodeContainer) node).getNode(fromId);
- Node to = ((NodeContainer) node).getNode(toId);
+ Node from = ((NodeContainer) getNodeContainer()).getNode(fromId);
+ Node to = ((NodeContainer) getNodeContainer()).getNode(toId);
Connection connection = new ConnectionImpl(from,
CONNECTION_DEFAULT_TYPE, to, CONNECTION_DEFAULT_TYPE);
if (uniqueId != null) {
connection.setMetaData(UNIQUE_ID, uniqueId);
@@ -212,7 +244,7 @@ public abstract class RuleFlowNodeContainerFactory<T
extends RuleFlowNodeContain
public abstract T variable(String name, DataType type, Object value,
String metaDataName, Object metaDataValue);
private <S extends Context> S getScope(String scopeType, Class<S>
scopeClass) {
- ContextContainer contextContainer = (ContextContainer) node;
+ ContextContainer contextContainer = (ContextContainer)
getNodeContainer();
Context scope = contextContainer.getDefaultContext(scopeType);
if (scope == null) {
try {
@@ -227,9 +259,9 @@ public abstract class RuleFlowNodeContainerFactory<T
extends RuleFlowNodeContain
}
public RuleFlowNodeContainerFactory<T, P> addCompensationContext(String
contextId) {
- if (node instanceof ContextContainer) {
+ if (getNodeContainer() instanceof ContextContainer) {
CompensationScope compensationScope = new CompensationScope();
- ContextContainer contextNode = (ContextContainer) node;
+ ContextContainer contextNode = (ContextContainer)
getNodeContainer();
contextNode.addContext(compensationScope);
contextNode.setDefaultContext(compensationScope);
compensationScope.setContextContainerId(contextId);
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowProcessFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowProcessFactory.java
index 881a28be78..a0acf5d140 100755
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowProcessFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowProcessFactory.java
@@ -95,8 +95,13 @@ public class RuleFlowProcessFactory extends
RuleFlowNodeContainerFactory<RuleFlo
return new RuleFlowProcessFactory(id, autoComplete);
}
+ @Override
+ protected org.jbpm.workflow.core.NodeContainer getNodeContainer() {
+ return nodeContainer;
+ }
+
protected RuleFlowProcessFactory(String id, boolean autoComplete) {
- super(null, null, new RuleFlowProcess(),
WorkflowElementIdentifierFactory.fromExternalFormat(id));
+ super(null, new RuleFlowProcess(), null,
WorkflowElementIdentifierFactory.fromExternalFormat(id));
getRuleFlowProcess().setAutoComplete(autoComplete);
}
@@ -111,7 +116,7 @@ public class RuleFlowProcessFactory extends
RuleFlowNodeContainerFactory<RuleFlo
}
protected RuleFlowProcess getRuleFlowProcess() {
- return (RuleFlowProcess) node;
+ return (RuleFlowProcess) nodeContainer;
}
@Override
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java
index 329534bbed..aacc99b20b 100644
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java
@@ -33,10 +33,15 @@ public abstract class AbstractCompositeNodeFactory<T
extends RuleFlowNodeContain
private WorkflowElementIdentifier linkedIncomingNodeId;
private WorkflowElementIdentifier linkedOutgoingNodeId;
- protected AbstractCompositeNodeFactory(P nodeContainerFactory,
NodeContainer nodeContainer, NodeContainer node, WorkflowElementIdentifier id) {
+ protected AbstractCompositeNodeFactory(P nodeContainerFactory,
NodeContainer nodeContainer, org.jbpm.workflow.core.Node node,
WorkflowElementIdentifier id) {
super(nodeContainerFactory, nodeContainer, node, id);
}
+ @Override
+ protected NodeContainer getNodeContainer() {
+ return getCompositeNode();
+ }
+
protected CompositeContextNode getCompositeNode() {
return (CompositeContextNode) node;
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ActionNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ActionNodeFactory.java
index 9ee08577ce..0df6e53d31 100755
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ActionNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ActionNodeFactory.java
@@ -71,4 +71,5 @@ public class ActionNodeFactory<T extends
RuleFlowNodeContainerFactory<T, ?>> ext
getActionNode().setAction(droolsAction);
return this;
}
+
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/DynamicNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/DynamicNodeFactory.java
index 8c9dffb8ce..53acb5bcdc 100755
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/DynamicNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/DynamicNodeFactory.java
@@ -54,4 +54,5 @@ public class DynamicNodeFactory<T extends
RuleFlowNodeContainerFactory<T, ?>> ex
getDynamicNode().setCompletionExpression(completionExpression);
return this;
}
+
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
index 0a22a65261..9eecb0bbf1 100755
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
@@ -18,9 +18,13 @@
*/
package org.jbpm.ruleflow.core.factory;
+import java.util.ArrayList;
+
+import org.jbpm.process.instance.impl.Action;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
import org.jbpm.workflow.core.Node;
import org.jbpm.workflow.core.NodeContainer;
+import org.jbpm.workflow.core.impl.DroolsConsequenceAction;
import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
import org.kie.api.definition.process.WorkflowElementIdentifier;
@@ -34,4 +38,23 @@ public abstract class ExtendedNodeFactory<T extends
NodeFactory<T, P>, P extends
return (ExtendedNodeImpl) getNode();
}
+ public T onEntryAction(String dialect, String action) {
+ return onActionScript(ExtendedNodeImpl.EVENT_NODE_ENTER, dialect,
action, null);
+ }
+
+ public T onExitAction(String dialect, String action) {
+ return onActionScript(ExtendedNodeImpl.EVENT_NODE_EXIT, dialect,
action, null);
+ }
+
+ public T onActionScript(String type, String dialect, String script, Action
compiledScript) {
+ DroolsConsequenceAction action = new DroolsConsequenceAction(dialect,
script);
+ if (compiledScript != null) {
+ action.setMetaData("Action", compiledScript);
+ }
+ if (getExtendedNode().getActions(type) == null) {
+ getExtendedNode().setActions(type, new ArrayList<>());
+ }
+ getExtendedNode().getActions(type).add(action);
+ return (T) this;
+ }
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/NodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/NodeFactory.java
index ba22a6d53b..bcbfb1f475 100755
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/NodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/NodeFactory.java
@@ -18,15 +18,10 @@
*/
package org.jbpm.ruleflow.core.factory;
-import java.util.ArrayList;
-
import org.jbpm.process.core.context.variable.Mappable;
-import org.jbpm.process.instance.impl.Action;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
import org.jbpm.workflow.core.Node;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.DroolsConsequenceAction;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
import org.kie.api.definition.process.WorkflowElementIdentifier;
public abstract class NodeFactory<T extends NodeFactory<T, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> implements MappableNodeFactory<T> {
@@ -76,27 +71,4 @@ public abstract class NodeFactory<T extends NodeFactory<T,
P>, P extends RuleFlo
return (Mappable) node;
}
- public T onEntryAction(String dialect, String action) {
- return onActionScript(ExtendedNodeImpl.EVENT_NODE_ENTER, dialect,
action, null);
- }
-
- public T onExitAction(String dialect, String action) {
- return onActionScript(ExtendedNodeImpl.EVENT_NODE_EXIT, dialect,
action, null);
- }
-
- public T onActionScript(String type, String dialect, String script, Action
compiledScript) {
- DroolsConsequenceAction action = new DroolsConsequenceAction(dialect,
script);
- if (compiledScript != null) {
- action.setMetaData("Action", compiledScript);
- }
- if (getExtendedNode().getActions(type) == null) {
- getExtendedNode().setActions(type, new ArrayList<>());
- }
- getExtendedNode().getActions(type).add(action);
- return (T) this;
- }
-
- private ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
- }
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ActionNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ActionNodeFactoryProvider.java
index 0a22a65261..7bf44360bf
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ActionNodeFactoryProvider.java
@@ -16,22 +16,23 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.ActionNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.ActionNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
-
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+public class ActionNodeFactoryProvider implements NodeFactoryProvider {
+ @Override
+ public boolean accept(Class<?> type) {
+ return ActionNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new ActionNodeFactory<P>(nodeContainerFactory, container,
id);
}
-
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/BoundaryEventNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 59%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/BoundaryEventNodeFactoryProvider.java
index 0a22a65261..ef90041777
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/BoundaryEventNodeFactoryProvider.java
@@ -16,22 +16,23 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.BoundaryEventNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.BoundaryEventNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
-
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+public class BoundaryEventNodeFactoryProvider implements NodeFactoryProvider {
+ @Override
+ public boolean accept(Class<?> type) {
+ return BoundaryEventNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new BoundaryEventNodeFactory<P>(nodeContainerFactory,
container, id);
}
-
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/CatchLinkNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 59%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/CatchLinkNodeFactoryProvider.java
index 0a22a65261..5f74211ae8
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/CatchLinkNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.CatchLinkNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.CatchLinkNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class CatchLinkNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return CatchLinkNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <T extends NodeFactory<T, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> T provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (T) new CatchLinkNodeFactory<P>(nodeContainerFactory,
container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/CompositeContextNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 58%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/CompositeContextNodeFactoryProvider.java
index 0a22a65261..8dbe4255aa
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/CompositeContextNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.CompositeContextNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.CompositeContextNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class CompositeContextNodeFactoryProvider implements
NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return CompositeContextNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new CompositeContextNodeFactory(nodeContainerFactory,
container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/DynamicNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/DynamicNodeFactoryProvider.java
index 0a22a65261..915a273ffe
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/DynamicNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.DynamicNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.DynamicNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class DynamicNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return DynamicNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new DynamicNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EndNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EndNodeFactoryProvider.java
index 0a22a65261..17ada6a17f
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EndNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.EndNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.EndNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class EndNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return EndNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <T extends NodeFactory<T, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> T provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (T) new EndNodeFactory<P>(nodeContainerFactory, container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EventNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EventNodeFactoryProvider.java
index 0a22a65261..c0643fa38e
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EventNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.EventNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.EventNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class EventNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return EventNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new EventNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EventSubProcessNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 58%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EventSubProcessNodeFactoryProvider.java
index 0a22a65261..91c10cba38
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/EventSubProcessNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.EventSubProcessNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.EventSubProcessNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class EventSubProcessNodeFactoryProvider implements NodeFactoryProvider
{
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return EventSubProcessNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new EventSubProcessNodeFactory<P>(nodeContainerFactory,
container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/FaultNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/FaultNodeFactoryProvider.java
index 0a22a65261..f5922d1392
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/FaultNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.FaultNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.FaultNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class FaultNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return FaultNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new FaultNodeFactory(nodeContainerFactory, container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ForEachNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ForEachNodeFactoryProvider.java
index 0a22a65261..750c759166
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ForEachNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.ForEachNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.ForEachNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class ForEachNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return ForEachNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new ForEachNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/HumanTaskNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 59%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/HumanTaskNodeFactoryProvider.java
index 0a22a65261..7a11553d8a
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/HumanTaskNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.HumanTaskNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.HumanTaskNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class HumanTaskNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return HumanTaskNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new HumanTaskNodeFactory<P>(nodeContainerFactory,
container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/JoinNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 61%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/JoinNodeFactoryProvider.java
index 0a22a65261..d873bb042e
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/JoinNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.JoinFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.Join;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class JoinNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return Join.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new JoinFactory<P>(nodeContainerFactory, container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/MilestoneNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 59%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/MilestoneNodeFactoryProvider.java
index 0a22a65261..05f6125732
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/MilestoneNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.MilestoneNodeFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.MilestoneNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class MilestoneNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return MilestoneNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new MilestoneNodeFactory(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/NodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 63%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/NodeFactoryProvider.java
index 0a22a65261..ae12e7ff81
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/NodeFactoryProvider.java
@@ -16,22 +16,17 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public interface NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
- }
+ boolean accept(Class<?> name);
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
- }
+ <T extends NodeFactory<T, P>, P extends RuleFlowNodeContainerFactory<P,
?>> T provide(P nodeContainerFactory, NodeContainer container,
WorkflowElementIdentifier id);
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/NodeFactoryProviderService.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/NodeFactoryProviderService.java
new file mode 100644
index 0000000000..7f628a9aff
--- /dev/null
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/NodeFactoryProviderService.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jbpm.ruleflow.core.factory.provider;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.ServiceLoader;
+import java.util.function.Predicate;
+
+import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.workflow.core.NodeContainer;
+import org.kie.api.definition.process.WorkflowElementIdentifier;
+
+public class NodeFactoryProviderService {
+
+ List<NodeFactoryProvider> providers;
+
+ public NodeFactoryProviderService() {
+ this.providers = new ArrayList<>();
+
ServiceLoader.load(NodeFactoryProvider.class).forEach(this.providers::add);
+ }
+
+ public <T extends NodeFactory<T, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> T newNodeFactory(Class<?> type, P
nodeContainerFactory, NodeContainer container, WorkflowElementIdentifier id) {
+ Predicate<NodeFactoryProvider> typeFilter = provider ->
provider.accept(type);
+ Optional<NodeFactoryProvider> provider =
providers.stream().filter(typeFilter).findAny();
+ if (provider.isEmpty()) {
+ throw new IllegalArgumentException("Provider for " +
type.getCanonicalName() + " not found");
+ }
+ return provider.get().provide(nodeContainerFactory, container, id);
+ }
+
+}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/RuleSetNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/RuleSetNodeFactoryProvider.java
index 0a22a65261..08804787eb
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/RuleSetNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.RuleSetNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.RuleSetNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class RuleSetNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return RuleSetNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new RuleSetNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/SplitNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 61%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/SplitNodeFactoryProvider.java
index 0a22a65261..a8dbffecd9
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/SplitNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.SplitFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.Split;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class SplitNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return Split.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new SplitFactory<P>(nodeContainerFactory, container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/StartNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/StartNodeFactoryProvider.java
index 0a22a65261..ee7fd45544
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/StartNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.StartNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.StartNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class StartNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return StartNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <T extends NodeFactory<T, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> T provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (T) new StartNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/StateNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/StateNodeFactoryProvider.java
index 0a22a65261..e42aa0f10d
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/StateNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.StateNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.StateNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class StateNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return StateNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <T extends NodeFactory<T, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> T provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (T) new StateNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/SubProcessNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 59%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/SubProcessNodeFactoryProvider.java
index 0a22a65261..504ccc0898
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/SubProcessNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.SubProcessNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.SubProcessNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class SubProcessNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return SubProcessNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new SubProcessNodeFactory<P>(nodeContainerFactory,
container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ThrowLinkNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 58%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ThrowLinkNodeFactoryProvider.java
index 0a22a65261..b1abdcbaff
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/ThrowLinkNodeFactoryProvider.java
@@ -16,22 +16,26 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.ThrowLinkNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.ThrowLinkNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class ThrowLinkNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return ThrowLinkNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ // TODO Auto-generated method stub
+ return (R) new ThrowLinkNodeFactory<P>(nodeContainerFactory,
container, id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/TimerNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/TimerNodeFactoryProvider.java
index 0a22a65261..ddcebe915c
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/TimerNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.TimerNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.TimerNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class TimerNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return TimerNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new TimerNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/WorkItemNodeFactoryProvider.java
old mode 100755
new mode 100644
similarity index 60%
copy from
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
copy to
jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/WorkItemNodeFactoryProvider.java
index 0a22a65261..e014dac4a9
---
a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/ExtendedNodeFactory.java
+++
b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/provider/WorkItemNodeFactoryProvider.java
@@ -16,22 +16,25 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.jbpm.ruleflow.core.factory;
+package org.jbpm.ruleflow.core.factory.provider;
import org.jbpm.ruleflow.core.RuleFlowNodeContainerFactory;
-import org.jbpm.workflow.core.Node;
+import org.jbpm.ruleflow.core.factory.NodeFactory;
+import org.jbpm.ruleflow.core.factory.WorkItemNodeFactory;
import org.jbpm.workflow.core.NodeContainer;
-import org.jbpm.workflow.core.impl.ExtendedNodeImpl;
+import org.jbpm.workflow.core.node.WorkItemNode;
import org.kie.api.definition.process.WorkflowElementIdentifier;
-public abstract class ExtendedNodeFactory<T extends NodeFactory<T, P>, P
extends RuleFlowNodeContainerFactory<P, ?>> extends NodeFactory<T, P> {
+public class WorkItemNodeFactoryProvider implements NodeFactoryProvider {
- protected ExtendedNodeFactory(P nodeContainerFactory, NodeContainer
nodeContainer, Node node, WorkflowElementIdentifier id) {
- super(nodeContainerFactory, nodeContainer, node, id);
+ @Override
+ public boolean accept(Class<?> type) {
+ return WorkItemNode.class.equals(type);
}
- protected ExtendedNodeImpl getExtendedNode() {
- return (ExtendedNodeImpl) getNode();
+ @Override
+ public <R extends NodeFactory<R, P>, P extends
RuleFlowNodeContainerFactory<P, ?>> R provide(P nodeContainerFactory,
NodeContainer container, WorkflowElementIdentifier id) {
+ return (R) new WorkItemNodeFactory<P>(nodeContainerFactory, container,
id);
}
}
diff --git
a/jbpm/jbpm-flow/src/main/resources/META-INF/services/org.jbpm.ruleflow.core.factory.provider.NodeFactoryProvider
b/jbpm/jbpm-flow/src/main/resources/META-INF/services/org.jbpm.ruleflow.core.factory.provider.NodeFactoryProvider
new file mode 100644
index 0000000000..e9a993216e
--- /dev/null
+++
b/jbpm/jbpm-flow/src/main/resources/META-INF/services/org.jbpm.ruleflow.core.factory.provider.NodeFactoryProvider
@@ -0,0 +1,21 @@
+org.jbpm.ruleflow.core.factory.provider.ActionNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.BoundaryEventNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.CatchLinkNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.CompositeContextNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.DynamicNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.EndNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.EventNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.EventSubProcessNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.FaultNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.ForEachNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.HumanTaskNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.JoinNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.MilestoneNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.RuleSetNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.SplitNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.StartNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.StateNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.SubProcessNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.ThrowLinkNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.TimerNodeFactoryProvider
+org.jbpm.ruleflow.core.factory.provider.WorkItemNodeFactoryProvider
\ No newline at end of file
diff --git
a/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples.model/Movie.java
b/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples/model/Movie.java
similarity index 100%
rename from
springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples.model/Movie.java
rename to
springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples/model/Movie.java
diff --git
a/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples.model/MovieGenre.java
b/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples/model/MovieGenre.java
similarity index 100%
rename from
springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples.model/MovieGenre.java
rename to
springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples/model/MovieGenre.java
diff --git
a/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples.model/Rating.java
b/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples/model/Rating.java
similarity index 100%
rename from
springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples.model/Rating.java
rename to
springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/acme/examples/model/Rating.java
diff --git
a/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/kie/kogito/integrationtests/VersionRestController.java
b/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/kie/kogito/integrationtests/VersionRestController.java
index 31df870580..7bc079282c 100644
---
a/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/kie/kogito/integrationtests/VersionRestController.java
+++
b/springboot/integration-tests/src/it/integration-tests-springboot-processes-it/src/main/java/org/kie/kogito/integrationtests/VersionRestController.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.kie.kogito.process.management;
+package org.kie.kogito.integrationtests;
import java.util.Map;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
