com.inubit.research.gui.plugins.choreography.branchingTree

Class BranchingTree

java.lang.Object

com.inubit.research.gui.plugins.choreography.branchingTree.BranchingTree

public abstract class BranchingTree
extends java.lang.Object

BranchingTree is a structure for representing the pathes of a BPMNDiagram. Because it is a tree, joining nodes cannot be represented and flow after joining of two pathes will be duplicated.

This data-structure was originally intended to analyse Choreography-diagrams and was enriched with some other functionalities. Be aware of the fact, that a BranchingTree can represent the flow of the diagram inverted, if it was built in this way, what is supported by TreeBuilder

From the outside of this class´ package (com.inubit.research.gui.plugins.choreography.branchingTree) only this abstract superclass and the class TreeBuilder can be used, there is no need for knowing the subclasses of BranchingTree.

Note: when the term "ChoreographyActivity" is used, it does not reference the implemented class ChoreographyActivity, but the conceptual class (as defined in the BPMN-specification). This means, it subsumes the classes ChoreographyActivity and ChoreographySubProcess.

Constructor Summary

Constructors

Constructor and Description
BranchingTree(BranchingTree parent)
BranchingTree(BranchingTree parent, ProcessNode node)

Method Summary

Modifier and Type	Method and Description
abstract java.util.Collection<ProcessNode>	activitiesWithParticipant(java.lang.String participant) identifies all choreography activities in this tree (i.e. this node and all of its descendants), that involve participant
abstract boolean	allAlternativesContainChoreographyActivities()
abstract boolean	allAlternativesContainMessageReceive() Checks, wheter all alternative pathes contain catching MessageIntermediate- Events or receive-tasks
abstract boolean	allAlternativesContainMultipleChoreographyActivities()
abstract boolean	allAlternativesContainNonEmptyNonEndEventOrInvolve(java.lang.String participant) checks, wheter all alternative pathes emerging from this node contain at least one StartEvent, that is not an empty StartEvent or a ChoreographyActivity, that involves participant
abstract boolean	allAlternativesInvolve(java.lang.String participant) checks, wheter all alternative pathes emerging from this node contain a ChoreographyActivity, that involves participant
abstract boolean	allParallelPathesSynchronizeBefore(ProcessNode node) checks, wheter all parallel pathes, into which the tree splits from this node on, synchronize again before the occurence of node
abstract boolean	allPathesContainOneOf(java.util.Collection<ProcessNode> nodes) states, wheter all pathes emerging from this node (i.e. all pathes that consist only of decendants of this node) contain at least one of the supplied nodes.
abstract boolean	contains(BranchingTree tree)
abstract boolean	contains(ProcessNode node) checks, wheter one of the descendant nodes of this BranchingTree-ndoe contains node.
protected boolean	containsKey(java.util.Map<java.lang.String,java.util.Map<java.lang.String,ProcessNode>> map, java.lang.String key1, java.lang.String key2) checks, wheter map contains key1 and the mapping of key1 contains the key key2
abstract boolean	containsOnIndirectWay(ProcessNode node) checks, wheter the tree emerging from this node contains node on some alternative path, but contains another ProcessNode before the first occurence of node.
abstract ProcessNode	createInstantiatingGateways(java.lang.String forParticipant, BPMNModel inModel, java.util.Map<java.lang.String,java.util.Map<java.lang.String,StartEvent>> startEvents, java.util.Map<java.lang.String,java.util.Map<java.lang.String,ProcessNode>> firstNode, java.util.Map<java.lang.String,Pool> pools) Derives instantiating gateways and start-events from the structure of this BranchingTree.
abstract BranchingTree	eraseFirstChoreographyActivity() removes the first choreography activity from this tree or, if this is not possible because it represents a split- or join-node, the tree will pretend its non-existence.
abstract BranchingTree	eraseFirstNode() removes the first ProcessNode from this tree or, if this is not possible because it represents a split- or join-node, the tree will pretend its non-existence.
abstract java.util.Set<ProcessNode>	firstNodesOf(java.lang.String participant) Collects all the first nodes, that involve the supplied participant.
abstract java.util.Collection<EventBasedGateway>	getAllEventBasedGateways() Collects all the EventBasedGateways, that this tree contains.
protected ProcessNode	getNode()
protected BranchingTree	getParent()
abstract java.util.Collection<java.lang.String>	getParticipants() collects all participants involved in ChoreographyActivities cotained in this tree
protected boolean	isParticipant(java.lang.String name) states, whether name is a participant of the ProcessNode represented by this BranchingTree-node
protected boolean	isReceive() Checks, wheter the node contained in this BranchingTree-node is a catching MessageIntermediateEvent or a receive-task.
abstract java.util.Collection<ProcessNode>	nextRealizedNodes(java.util.Map<java.lang.String,java.util.Map<java.lang.String,ProcessNode>> realizedNodes, java.lang.String participant) returns the first ProcessNode of every branch, that has an entry in realizedNodes for the supplied participant
abstract boolean	noAlternativesInvolve(java.lang.String participant) checks, wheter none of the descendant nodes of this contains a ChoreographyActivity that involves participant
abstract boolean	noPathesContainNonEmptyStartEvent() checks, wheter the whole tree emerging from this node contains no StartEvents, that are not Empty StartEvents (instances exactly of StartEvent, not of one of its subclasses)
abstract java.util.Collection<ProcessNode>	parallelGatewaysBeforeFirstParticipationOf(java.util.Collection<java.lang.String> participants) collects all parallel gateways, that occur in any path emerging from this BranchingTree-Node before all of the supplied participants involved in some ChoreographyActivity
int	pathFromRootCount(ProcessNode node) gives the number of occurences of a node in the path to (i.e. the ancestors of) this BranchingTree object.
protected abstract java.util.Map<java.lang.String,java.util.Collection<BranchingTree>>	processNodeOccurenceMap() builds the map needed for checking synchronization of pathes (e.g. the second parameter of synchronizesWithOneOf): it maps each ProcessNode-ID occuring in this tree to the BranchingTee-node, that contains this ProcessNode.
abstract void	setNext(BranchingTree next) sets the next node for this BranchingTree-node
protected void	setNode(ProcessNode node)
protected void	setParent(BranchingTree parent)
abstract boolean	synchronizesWithAllBeforeAndKeepsSynchronized(java.util.Collection<BranchingTree> branches, java.util.Map<java.lang.String,java.util.Collection<BranchingTree>> nodeOccurences, ProcessNode before) checks, wheter all pathes emerging from this node synchronize with all of the supplied branches, before the pathes contain the ProcessNode before and wheter the pathes keep synchronized (i.e. if the path splits to parallel pathes again, they also synchronize before the node "before")
protected abstract boolean	synchronizesWithOneOf(java.util.Collection<BranchingTree> pathes, java.util.Map<java.lang.String,java.util.Collection<BranchingTree>> processNodeOccurences) checks, wheter all alternatives emerging from this BranchingTree-node synchronize with one of the pathes in pathes.
abstract boolean	trimAndEliminateToEndingAtNode(ProcessNode node) Cuts all branches after the given node and eliminates branches, which do not involve this node

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BranchingTree

public BranchingTree(BranchingTree parent)

BranchingTree

public BranchingTree(BranchingTree parent,
                     ProcessNode node)

Method Detail

getNode

protected ProcessNode getNode()

setNode

protected void setNode(ProcessNode node)

setParent

protected void setParent(BranchingTree parent)

getParent

protected BranchingTree getParent()

contains

public abstract boolean contains(ProcessNode node)

checks, wheter one of the descendant nodes of this BranchingTree-ndoe contains node.

setNext

public abstract void setNext(BranchingTree next)

sets the next node for this BranchingTree-node

allAlternativesInvolve

public abstract boolean allAlternativesInvolve(java.lang.String participant)

checks, wheter all alternative pathes emerging from this node contain a ChoreographyActivity, that involves participant

noAlternativesInvolve

public abstract boolean noAlternativesInvolve(java.lang.String participant)

checks, wheter none of the descendant nodes of this contains a ChoreographyActivity that involves participant

pathFromRootCount

public int pathFromRootCount(ProcessNode node)

gives the number of occurences of a node in the path to (i.e. the ancestors of) this BranchingTree object.

Parameters:

node - the node, whichs occurences to count

Returns:

the number of occurences in the path to this node

activitiesWithParticipant

public abstract java.util.Collection<ProcessNode> activitiesWithParticipant(java.lang.String participant)

identifies all choreography activities in this tree (i.e. this node and all of its descendants), that involve participant

Parameters:

participant - the participant, who´s activities should be identified

allAlternativesContainChoreographyActivities

public abstract boolean allAlternativesContainChoreographyActivities()

allAlternativesContainMultipleChoreographyActivities

public abstract boolean allAlternativesContainMultipleChoreographyActivities()

isParticipant

protected boolean isParticipant(java.lang.String name)

states, whether name is a participant of the ProcessNode represented by this BranchingTree-node

trimAndEliminateToEndingAtNode

public abstract boolean trimAndEliminateToEndingAtNode(ProcessNode node)

Cuts all branches after the given node and eliminates branches, which do not involve this node

Returns:

wheter this path is to be eliminated

allPathesContainOneOf

public abstract boolean allPathesContainOneOf(java.util.Collection<ProcessNode> nodes)

states, wheter all pathes emerging from this node (i.e. all pathes that consist only of decendants of this node) contain at least one of the supplied nodes. A path is also considered containing a node, if does not contain a node itself, but synchronizes with a path containing one of the nodes.

Parameters:

nodes - the nodes, of which at least one should occur

Returns:

wheter at least one of the nodes is contained in every alternative path

synchronizesWithOneOf

protected abstract boolean synchronizesWithOneOf(java.util.Collection<BranchingTree> pathes,
                                                 java.util.Map<java.lang.String,java.util.Collection<BranchingTree>> processNodeOccurences)

checks, wheter all alternatives emerging from this BranchingTree-node synchronize with one of the pathes in pathes.

Parameters:

pathes - the pathes, with which to synchronize

processNodeOccurences - a mapping from Node-IDs of all ProcessNodes, that occur in one of the pathes to a Collection of BranchingTrees, that represent the node with the given ID.

Returns:

true, if all alternatives emerging from this point synchronize with one of the alternative pathes.

processNodeOccurenceMap

protected abstract java.util.Map<java.lang.String,java.util.Collection<BranchingTree>> processNodeOccurenceMap()

builds the map needed for checking synchronization of pathes (e.g. the second parameter of synchronizesWithOneOf): it maps each ProcessNode-ID occuring in this tree to the BranchingTee-node, that contains this ProcessNode.

Returns:

the generated mapping from ProcessNode-IDs to BranchingTree-nodes

eraseFirstChoreographyActivity

public abstract BranchingTree eraseFirstChoreographyActivity()

removes the first choreography activity from this tree or, if this is not possible because it represents a split- or join-node, the tree will pretend its non-existence. If the tree splits before the first activity, the first activity of every branch (no matter, wheter it splits alternative or parallel) will be erased.

Returns:

the BranchingTree, that resulted from erasing the first ChoreographyActivity. The root of the tree does not change

nextRealizedNodes

public abstract java.util.Collection<ProcessNode> nextRealizedNodes(java.util.Map<java.lang.String,java.util.Map<java.lang.String,ProcessNode>> realizedNodes,
                                                                    java.lang.String participant)

returns the first ProcessNode of every branch, that has an entry in realizedNodes for the supplied participant

Parameters:

realizedNodes - a mapping from choreography-node-id to a mapping from participant-name to a colaboration-node

participant - the name of the participant, whom should be paid attention to

containsKey

protected boolean containsKey(java.util.Map<java.lang.String,java.util.Map<java.lang.String,ProcessNode>> map,
                              java.lang.String key1,
                              java.lang.String key2)

checks, wheter map contains key1 and the mapping of key1 contains the key key2

Parameters:

map - the map, that is to be checked for containing the keys

key1 - the first-level key

key2 - the second-level key

Returns:

true, if map contains a mapping from key1 to another map, that contains the key key2

noPathesContainNonEmptyStartEvent

public abstract boolean noPathesContainNonEmptyStartEvent()

checks, wheter the whole tree emerging from this node contains no StartEvents, that are not Empty StartEvents (instances exactly of StartEvent, not of one of its subclasses)

Returns:

true, if the whole tree contains no ProcessNode, that is a StartEvent, but not one of its subclasses

allAlternativesContainNonEmptyNonEndEventOrInvolve

public abstract boolean allAlternativesContainNonEmptyNonEndEventOrInvolve(java.lang.String participant)

checks, wheter all alternative pathes emerging from this node contain at least one StartEvent, that is not an empty StartEvent or a ChoreographyActivity, that involves participant

Returns:

true, if one of the mentioned kinds on nodes occurs in every alternative path

containsOnIndirectWay

public abstract boolean containsOnIndirectWay(ProcessNode node)

checks, wheter the tree emerging from this node contains node on some alternative path, but contains another ProcessNode before the first occurence of node.

Parameters:

node - the node, whichs occurence is to be checked

Returns:

true, if any path emerging from this BranchingTree-node contains some different ProcessNode than node, and later contains node

eraseFirstNode

public abstract BranchingTree eraseFirstNode()

removes the first ProcessNode from this tree or, if this is not possible because it represents a split- or join-node, the tree will pretend its non-existence. If the tree splits before the first activity, the first activity of every branch (no matter, wheter it splits alternative or parallel) will be erased. The difference to eraseFirstChoreographyActivity is, that eraseFirstNode may erase any ProcessNode and not only ChoreographyActivities.

Returns:

the BranchingTree, that resulted from erasing the first node. The root of the tree does not change (the return value is only relevant for internal implementation)

getParticipants

public abstract java.util.Collection<java.lang.String> getParticipants()

collects all participants involved in ChoreographyActivities cotained in this tree

Returns:

a Collection of participant names

parallelGatewaysBeforeFirstParticipationOf

public abstract java.util.Collection<ProcessNode> parallelGatewaysBeforeFirstParticipationOf(java.util.Collection<java.lang.String> participants)

collects all parallel gateways, that occur in any path emerging from this BranchingTree-Node before all of the supplied participants involved in some ChoreographyActivity

Parameters:

participants - a set of participant names

Returns:

the collection of gateways, that satisfy the condition stated above

allParallelPathesSynchronizeBefore

public abstract boolean allParallelPathesSynchronizeBefore(ProcessNode node)

checks, wheter all parallel pathes, into which the tree splits from this node on, synchronize again before the occurence of node

Parameters:

node - the node at which to stop looking for synchronization

synchronizesWithAllBeforeAndKeepsSynchronized

public abstract boolean synchronizesWithAllBeforeAndKeepsSynchronized(java.util.Collection<BranchingTree> branches,
                                                                      java.util.Map<java.lang.String,java.util.Collection<BranchingTree>> nodeOccurences,
                                                                      ProcessNode before)

checks, wheter all pathes emerging from this node synchronize with all of the supplied branches, before the pathes contain the ProcessNode before and wheter the pathes keep synchronized (i.e. if the path splits to parallel pathes again, they also synchronize before the node "before")

Parameters:

branches - the collection of branches, with wich it should synchronize

nodeOccurences - a mapping from ProcessNode-IDs to a Collection of BranchingTree-nodes, that contain the ProcessNode with this ID

before - the node, at which to stop the search for synchronization (by failing)

contains

public abstract boolean contains(BranchingTree tree)

Returns:

true, if tree is a descendant of this BranchingTree-node

createInstantiatingGateways

public abstract ProcessNode createInstantiatingGateways(java.lang.String forParticipant,
                                                        BPMNModel inModel,
                                                        java.util.Map<java.lang.String,java.util.Map<java.lang.String,StartEvent>> startEvents,
                                                        java.util.Map<java.lang.String,java.util.Map<java.lang.String,ProcessNode>> firstNode,
                                                        java.util.Map<java.lang.String,Pool> pools)

Derives instantiating gateways and start-events from the structure of this BranchingTree. The new ProcessNodes will be generated into another model, than the one, that this BranchingTree represents.

Parameters:

forParticipant - the name of the participant, for whom and in whose poolto generate instantiating gateways and StartEvents

inModel - the model, in which to generate these nodes

startEvents - maps the IDs of nodes of the choreography-diagram, that this tree represents, to a map, that maps the name of a participant to a StartEvent, that was created for the node with the given ID. When new StartEvents are generated, they will be recorded in this map.

firstNode - maps the IDs of nodes of the choreography-diagram, that this tree represents, to a map, that maps the name of a participant to the first ProcessNode, that is involved in enforcing the choreography-node with the given ID.

pools - maps the name of a participant to that participant´s pool

firstNodesOf

public abstract java.util.Set<ProcessNode> firstNodesOf(java.lang.String participant)

Collects all the first nodes, that involve the supplied participant. A ProcessNode is a first node, if it is preceeded by no other nodes in the path from this BranchingTree-node to the BranchingTree-node containing the ProcessNode.

getAllEventBasedGateways

public abstract java.util.Collection<EventBasedGateway> getAllEventBasedGateways()

Collects all the EventBasedGateways, that this tree contains.

allAlternativesContainMessageReceive

public abstract boolean allAlternativesContainMessageReceive()

Checks, wheter all alternative pathes contain catching MessageIntermediate- Events or receive-tasks

Returns:

true, if every alternative path contains at least one catching MessageIntermediateEvent or at least one receive-task

isReceive

protected boolean isReceive()

Checks, wheter the node contained in this BranchingTree-node is a catching MessageIntermediateEvent or a receive-task.