AbstractBranchingProcess (Business Process Technologies 4 Java (jBPT)

java.lang.Object
- org.jbpt.petri.unfolding.AbstractBranchingProcess<BPN,C,E,F,N,P,T,M>

All Implemented Interfaces:: Cloneable, IBranchingProcess<BPN,C,E,F,N,P,T,M>, IOrderingRelationsDescriptor<BPN,N>

Direct Known Subclasses:: AbstractCompletePrefixUnfolding, AbstractProcess, BranchingProcess

public abstract class AbstractBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
extends Object
implements IBranchingProcess<BPN,C,E,F,N,P,T,M>

Abstract implementation of a branching process of a net system.

Author:: Artem Polyvyanyy

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<BPN,Set<BPN>>`	`ca`
`protected Map<BPN,Set<BPN>>`	`co`
`protected Set<C>`	`conds`
`protected Set<E>`	`events`
`protected ICut<BPN,C,E,F,N,P,T,M>`	`iniBP`
`protected List<E>`	`log`
`protected INetSystem<F,N,P,T,M>`	`sys`

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractBranchingProcess()

protected AbstractBranchingProcess(INetSystem<F,N,P,T,M> sys)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractBranchingProcess()`
`protected`	`AbstractBranchingProcess(INetSystem<F,N,P,T,M> sys)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`appendCondition(C condition)` Append condition to this branching process.
`boolean`	`appendEvent(E event)` Append event to this branching process.
`boolean`	`appendTransition(T transition)` Append a fresh event that corresponds to the given transition.
`boolean`	`areCausal(BPN n1, BPN n2)` Check if two nodes of this branching process are in the causal relation.
`boolean`	`areConcurrent(BPN n1, BPN n2)` Check if two nodes of this branching process are concurrent.
`boolean`	`areInConflict(BPN n1, BPN n2)` Check if two nodes of this branching process are in conflict.
`boolean`	`areInverseCausal(BPN n1, BPN n2)` Check if two nodes of this branching process are in the inverse causal relation.
`boolean`	`areMutuallyConcurrent(Collection<C> conditions)`
`IBranchingProcess<BPN,C,E,F,N,P,T,M>`	`clone()`
`void`	`constructInitialBranchingProcess()` Construct initial branching process (only if this branching process is empty).
`C`	`createCondition(P place, E event)` Factory method to provide a condition of the branching process implementation.
`ICoSet<BPN,C,E,F,N,P,T,M>`	`createCoSet()` Factory method to provide a co-set of the branching process implementation.
`ICut<BPN,C,E,F,N,P,T,M>`	`createCut()` Factory method to provide a cut of the branching process implementation.
`E`	`createEvent(T transition, ICoSet<BPN,C,E,F,N,P,T,M> preConditions)` Factory method to provide an event of the branching process implementation.
`Set<BPN>`	`getCausalPredecessors(BPN node)` Get causal predecessors of a given node of this branching process.
`Set<C>`	`getConditions()` Get conditions of this branching process.
`Set<C>`	`getConditions(P place)` Get conditions of this branching process that correspond to a given place in the originative net system.
`Set<ICut<BPN,C,E,F,N,P,T,M>>`	`getCuts(Collection<P> places)` Get cuts of this branching process that refer to the provided collection of places.
`Set<E>`	`getEvents()` Get events of this branching process.
`Set<E>`	`getEvents(T transition)` Get events of this branching process that correspond to a given transition in the originative net system.
`ICut<BPN,C,E,F,N,P,T,M>`	`getInitialCut()` Get initial cut of this branching process, i.e., the set of condition without input events.
`List<E>`	`getLog()` Get log of events which was used to construct this branching process.
`Set<C>`	`getMax()` Get maximum, i.e., conditions without output events, of this branching process.
`Set<C>`	`getMin()` Get minimum, i.e., conditions without input events, of this branching process.
`IOccurrenceNet<BPN,C,E,F,N,P,T,M>`	`getOccurrenceNet()` Get occurrence net.
`OrderingRelationType`	`getOrderingRelation(BPN n1, BPN n2)` Get ordering relation between two nodes of this branching process.
`INetSystem<F,N,P,T,M>`	`getOriginativeNetSystem()` Get originative net system of this branching process.
`Set<P>`	`getPlaces(Collection<C> conditions)` Get places of the originative net system that are associated with the given conditions.
`Set<T>`	`getTransitions(Collection<E> events)` Get transitions of the originative net system that are associated with the given events.
`protected void`	`initialize()`
`boolean`	`isConflictFree()` Check if this branching process is conflict free.
`boolean`	`isCut(Collection<C> conditions)` Check if a given collection of conditions is a cut in this branching process.
`boolean`	`isSafe()` Check if this branching process is safe.
`void`	`setNetSystem(INetSystem<F,N,P,T,M> system)` Set net system of this branching process.
`protected void`	`updateCausalityCondition(C c)`

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - sys
```
protected INetSystem<F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>> sys
```
  - log
```
protected List<E extends IEvent<BPN,C,E,F,N,P,T,M>> log
```
  - events
```
protected Set<E extends IEvent<BPN,C,E,F,N,P,T,M>> events
```
  - conds
```
protected Set<C extends ICondition<BPN,C,E,F,N,P,T,M>> conds
```
  - iniBP
```
protected ICut<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>> iniBP
```
  - ca
```
protected Map<BPN extends IBPNode<N>,Set<BPN extends IBPNode<N>>> ca
```
  - co
```
protected Map<BPN extends IBPNode<N>,Set<BPN extends IBPNode<N>>> co
```
- Constructor Detail
  - AbstractBranchingProcess
```
protected AbstractBranchingProcess()
```
  - AbstractBranchingProcess
```
protected AbstractBranchingProcess(INetSystem<F,N,P,T,M> sys)
```
- Method Detail
  - initialize
```
protected void initialize()
```
  - constructInitialBranchingProcess
```
public void constructInitialBranchingProcess()
```
    Description copied from interface: IBranchingProcess
    
    Construct initial branching process (only if this branching process is empty).
    
    Specified by:
    
    constructInitialBranchingProcess in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
  - getConditions
```
public Set<C> getConditions()
```
    Description copied from interface: IBranchingProcess
    
    Get conditions of this branching process.
    
    Specified by:
    
    getConditions in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Conditions of this branching process.
  - getConditions
```
public Set<C> getConditions(P place)
```
    Description copied from interface: IBranchingProcess
    
    Get conditions of this branching process that correspond to a given place in the originative net system.
    
    Specified by:
    
    getConditions in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Conditions of this branching process that correspond to the given place.
  - getEvents
```
public Set<E> getEvents()
```
    Description copied from interface: IBranchingProcess
    
    Get events of this branching process.
    
    Specified by:
    
    getEvents in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Events of this branching process.
  - getEvents
```
public Set<E> getEvents(T transition)
```
    Description copied from interface: IBranchingProcess
    
    Get events of this branching process that correspond to a given transition in the originative net system.
    
    Specified by:
    
    getEvents in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Events of this branching process that correspond to the given transition.
  - getOriginativeNetSystem
```
public INetSystem<F,N,P,T,M> getOriginativeNetSystem()
```
    Description copied from interface: IBranchingProcess
    
    Get originative net system of this branching process.
    
    Specified by:
    
    getOriginativeNetSystem in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    The originative net system of this branching process.
  - areCausal
```
public boolean areCausal(BPN n1,
                BPN n2)
```
    Description copied from interface: IOrderingRelationsDescriptor
    
    Check if two nodes of this branching process are in the causal relation.
    
    Specified by:
    
    areCausal in interface IOrderingRelationsDescriptor<BPN extends IBPNode<N>,N extends INode>
    
    Parameters:
    n1 - Node of this branching process.
    n2 - Node of this branching process.
    
    Returns:
    true if 'n1' and 'n2' are in the causal relation; otherwise false.
  - areInverseCausal
```
public boolean areInverseCausal(BPN n1,
                       BPN n2)
```
    Description copied from interface: IOrderingRelationsDescriptor
    
    Check if two nodes of this branching process are in the inverse causal relation.
    
    Specified by:
    
    areInverseCausal in interface IOrderingRelationsDescriptor<BPN extends IBPNode<N>,N extends INode>
    
    Parameters:
    n1 - Node of this branching process.
    n2 - Node of this branching process.
    
    Returns:
    true if 'n1' and 'n2' are in the inverse causal relation; otherwise false.
  - areConcurrent
```
public boolean areConcurrent(BPN n1,
                    BPN n2)
```
    Description copied from interface: IOrderingRelationsDescriptor
    
    Check if two nodes of this branching process are concurrent.
    
    Specified by:
    
    areConcurrent in interface IOrderingRelationsDescriptor<BPN extends IBPNode<N>,N extends INode>
    
    Parameters:
    n1 - Node of this branching process.
    n2 - Node of this branching process.
    
    Returns:
    true if 'n1' and 'n2' are concurrent; otherwise false.
  - areInConflict
```
public boolean areInConflict(BPN n1,
                    BPN n2)
```
    Description copied from interface: IOrderingRelationsDescriptor
    
    Check if two nodes of this branching process are in conflict.
    
    Specified by:
    
    areInConflict in interface IOrderingRelationsDescriptor<BPN extends IBPNode<N>,N extends INode>
    
    Parameters:
    n1 - Node of this branching process.
    n2 - Node of this branching process.
    
    Returns:
    true if 'n1' and 'n2' are in conflict; otherwise false.
  - getOrderingRelation
```
public OrderingRelationType getOrderingRelation(BPN n1,
                                       BPN n2)
```
    Description copied from interface: IOrderingRelationsDescriptor
    
    Get ordering relation between two nodes of this branching process.
    
    Specified by:
    
    getOrderingRelation in interface IOrderingRelationsDescriptor<BPN extends IBPNode<N>,N extends INode>
    
    Parameters:
    n1 - Node of this branching process.
    n2 - Node of this branching process.
    
    Returns:
    Ordering relation between 'n1' and 'n2', see OrderingRelationType.
  - createCondition
```
public C createCondition(P place,
                E event)
```
    Description copied from interface: IBranchingProcess
    
    Factory method to provide a condition of the branching process implementation.
    
    Specified by:
    
    createCondition in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    place - A place.
    event - An event.
    
    Returns:
    A fresh condition.
  - createEvent
```
public E createEvent(T transition,
            ICoSet<BPN,C,E,F,N,P,T,M> preConditions)
```
    Description copied from interface: IBranchingProcess
    
    Factory method to provide an event of the branching process implementation.
    
    Specified by:
    
    createEvent in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    transition - A transition.
    preConditions - The preset of 't'.
    
    Returns:
    A fresh event.
  - appendCondition
```
public boolean appendCondition(C condition)
```
    Description copied from interface: IBranchingProcess
    
    Append condition to this branching process.
    
    Specified by:
    
    appendCondition in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    condition - Condition to append.
    
    Returns:
    true if condition was appended.
  - updateCausalityCondition
```
protected void updateCausalityCondition(C c)
```
  - appendEvent
```
public boolean appendEvent(E event)
```
    Description copied from interface: IBranchingProcess
    
    Append event to this branching process.
    
    Specified by:
    
    appendEvent in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    true if event was appended; otherwise false.
  - appendTransition
```
public boolean appendTransition(T transition)
```
    Description copied from interface: IBranchingProcess
    
    Append a fresh event that corresponds to the given transition.
    
    Specified by:
    
    appendTransition in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    transition - Transition that a fresh event should refer to.
    
    Returns:
    true if event was appended; otherwise false.
  - getInitialCut
```
public ICut<BPN,C,E,F,N,P,T,M> getInitialCut()
```
    Description copied from interface: IBranchingProcess
    
    Get initial cut of this branching process, i.e., the set of condition without input events.
    
    Specified by:
    
    getInitialCut in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Initial cut of this branching process.
  - createCoSet
```
public ICoSet<BPN,C,E,F,N,P,T,M> createCoSet()
```
    Description copied from interface: IBranchingProcess
    
    Factory method to provide a co-set of the branching process implementation.
    
    Specified by:
    
    createCoSet in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    A fresh co-set.
  - createCut
```
public ICut<BPN,C,E,F,N,P,T,M> createCut()
```
    Description copied from interface: IBranchingProcess
    
    Factory method to provide a cut of the branching process implementation.
    
    Specified by:
    
    createCut in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    A fresh cut.
  - getCausalPredecessors
```
public Set<BPN> getCausalPredecessors(BPN node)
```
    Description copied from interface: IBranchingProcess
    
    Get causal predecessors of a given node of this branching process.
    
    Specified by:
    
    getCausalPredecessors in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    node - Node of this branching process.
    
    Returns:
    Set of all causal predecessors of the given node.
  - isConflictFree
```
public boolean isConflictFree()
```
    Description copied from interface: IBranchingProcess
    
    Check if this branching process is conflict free. Note that a branching process contains no backward conflicts by definition. Hence, the absense of forward conflicts is checked.
    
    Specified by:
    
    isConflictFree in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    true if this branching process is conflict free; otherwise .
  - setNetSystem
```
public void setNetSystem(INetSystem<F,N,P,T,M> system)
```
    Description copied from interface: IBranchingProcess
    
    Set net system of this branching process. Once the new net system is set, the old branching process is cleared and the initial branching process for the new net system is constructued.
    
    Specified by:
    
    setNetSystem in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    system - Net system to use as the originative system of this branching process.
  - isSafe
```
public boolean isSafe()
```
    Description copied from interface: IBranchingProcess
    
    Check if this branching process is safe.
    
    Specified by:
    
    isSafe in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    true if this branching process is safe; false otherwise.
  - getMin
```
public Set<C> getMin()
```
    Description copied from interface: IBranchingProcess
    
    Get minimum, i.e., conditions without input events, of this branching process. Note that minimum of a branching process is a cut (maximal co-set of conditions)!
    
    Specified by:
    
    getMin in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Set of conditions without input events.
  - getMax
```
public Set<C> getMax()
```
    Description copied from interface: IBranchingProcess
    
    Get maximum, i.e., conditions without output events, of this branching process. Note that maximum of a conflict-free (see IBranchingProcess.isConflictFree()) branching process is a cut (maximal co-set of conditions)!
    
    Specified by:
    
    getMax in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Set of conditions without input events.
  - getPlaces
```
public Set<P> getPlaces(Collection<C> conditions)
```
    Description copied from interface: IBranchingProcess
    
    Get places of the originative net system that are associated with the given conditions.
    
    Specified by:
    
    getPlaces in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    conditions - Conditions of this branching process.
    
    Returns:
    Set of places associated with the given conditions.
  - getTransitions
```
public Set<T> getTransitions(Collection<E> events)
```
    Description copied from interface: IBranchingProcess
    
    Get transitions of the originative net system that are associated with the given events.
    
    Specified by:
    
    getTransitions in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    events - Events of this branching process.
    
    Returns:
    Set of transitions associated with the given events.
  - getOccurrenceNet
```
public IOccurrenceNet<BPN,C,E,F,N,P,T,M> getOccurrenceNet()
```
    Description copied from interface: IBranchingProcess
    
    Get occurrence net.
    
    Specified by:
    
    getOccurrenceNet in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    Occurrence net.
  - clone
```
public IBranchingProcess<BPN,C,E,F,N,P,T,M> clone()
```
    Specified by:
    
    clone in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Overrides:
    
    clone in class Object
  - isCut
```
public boolean isCut(Collection<C> conditions)
```
    Description copied from interface: IBranchingProcess
    
    Check if a given collection of conditions is a cut in this branching process.
    
    Specified by:
    
    isCut in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    conditions - Collection of conditions.
    
    Returns:
    true if the given collection of conditions is a cut of this branching process; otherwise false.
  - areMutuallyConcurrent
```
public boolean areMutuallyConcurrent(Collection<C> conditions)
```
    Specified by:
    
    areMutuallyConcurrent in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
  - getCuts
```
public Set<ICut<BPN,C,E,F,N,P,T,M>> getCuts(Collection<P> places)
```
    Description copied from interface: IBranchingProcess
    
    Get cuts of this branching process that refer to the provided collection of places.
    
    Specified by:
    
    getCuts in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Parameters:
    places - Collection of places of the originative net system.
    
    Returns:
    Cuts that refer to the provided collection of places.
  - getLog
```
public List<E> getLog()
```
    Description copied from interface: IBranchingProcess
    
    Get log of events which was used to construct this branching process.
    
    Specified by:
    
    getLog in interface IBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>
    
    Returns:
    List of events in the order they were appended to this branching process.

Class AbstractBranchingProcess<BPN extends IBPNode<N>,C extends ICondition<BPN,C,E,F,N,P,T,M>,E extends IEvent<BPN,C,E,F,N,P,T,M>,F extends IFlow<N>,N extends INode,P extends IPlace,T extends ITransition,M extends IMarking<F,N,P,T>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sys

log

events

conds

iniBP

ca

co

Constructor Detail

AbstractBranchingProcess

AbstractBranchingProcess

Method Detail

initialize

constructInitialBranchingProcess

getConditions

getConditions

getEvents

getEvents

getOriginativeNetSystem

areCausal

areInverseCausal

areConcurrent

areInConflict

getOrderingRelation

createCondition

createEvent

appendCondition

updateCausalityCondition

appendEvent

appendTransition

getInitialCut

createCoSet

createCut

getCausalPredecessors

isConflictFree

setNetSystem

isSafe

getMin

getMax

getPlaces

getTransitions

getOccurrenceNet

clone

isCut

areMutuallyConcurrent

getCuts

getLog