Package org.camunda.bpm.engine.impl.pvm.runtime

Class PvmExecutionImpl

java.lang.Object
org.camunda.bpm.engine.impl.core.variable.scope.AbstractVariableScope
org.camunda.bpm.engine.impl.core.instance.CoreExecution
org.camunda.bpm.engine.impl.pvm.runtime.PvmExecutionImpl
All Implemented Interfaces:
Serializable, BaseDelegateExecution, BpmnModelExecutionContext, DelegateExecution, ProcessEngineServicesAware, VariableScope, VariableEventDispatcher, ActivityExecution, PvmExecution, PvmProcessInstance
Direct Known Subclasses:
ExecutionEntity, ExecutionImpl
public abstract class PvmExecutionImpl extends CoreExecution implements ActivityExecution, PvmProcessInstance
Author:
Daniel Meyer, Roman Smirnov, Sebastian Menski
See Also:

  • Field Details

    • processDefinition

      protected transient ProcessDefinitionImpl processDefinition

    • scopeInstantiationContext

      protected transient ScopeInstantiationContext scopeInstantiationContext

    • ignoreAsync

      protected transient boolean ignoreAsync

    • isStarting

      protected transient boolean isStarting
      true for process instances in the initial phase. Currently this controls that historic variable updates created during this phase receive the initial flag (see HistoricVariableUpdateEventEntity#isInitial).

    • activity

      protected transient ActivityImpl activity
      current activity

    • nextActivity

      protected transient PvmActivity nextActivity
      the activity which is to be started next

    • transition

      protected transient TransitionImpl transition
      the transition that is currently being taken

    • transitionsToTake

      protected transient List<PvmTransition> transitionsToTake
      A list of outgoing transitions from the current activity that are going to be taken

    • activityInstanceId

      protected String activityInstanceId
      the unique id of the current activity instance

    • caseInstanceId

      protected String caseInstanceId
      the id of a case associated with this execution

    • replacedBy

      protected PvmExecutionImpl replacedBy

    • deleteRoot

      protected boolean deleteRoot

    • deleteReason

      protected String deleteReason

    • externallyTerminated

      protected boolean externallyTerminated

    • isActive

      protected boolean isActive
      indicates if this execution represents an active path of execution. Executions are made inactive in the following situations:
      • an execution enters a nested scope
      • an execution is split up into multiple concurrent executions, then the parent is made inactive.
      • an execution has arrived in a parallel gateway or join and that join has not yet activated/fired.
      • an execution is ended.

    • isScope

      protected boolean isScope

    • isConcurrent

      protected boolean isConcurrent

    • isEnded

      protected boolean isEnded

    • isEventScope

      protected boolean isEventScope

    • isRemoved

      protected boolean isRemoved

    • preserveScope

      protected boolean preserveScope
      transient; used for process instance modification to preserve a scope from getting deleted

    • activityInstanceState

      protected int activityInstanceState
      marks the current activity instance

    • activityInstanceEndListenersFailed

      protected boolean activityInstanceEndListenersFailed

    • sequenceCounter

      protected long sequenceCounter

    • delayedEvents

      protected transient List<DelayedVariableEvent> delayedEvents
      Contains the delayed variable events, which will be dispatched on a save point.

  • Constructor Details

    • PvmExecutionImpl

      public PvmExecutionImpl()

  • Method Details

    • createExecution

      public abstract PvmExecutionImpl createExecution()
      creates a new execution. properties processDefinition, processInstance and activity will be initialized.
      Specified by:
      createExecution in interface ActivityExecution

    • createSubProcessInstance

      public PvmExecutionImpl createSubProcessInstance(PvmProcessDefinition processDefinition)
      Description copied from interface: ActivityExecution
      creates a new sub process instance. The current execution will be the super execution of the created execution.
      Specified by:
      createSubProcessInstance in interface ActivityExecution
      Parameters:
      processDefinition - The PvmProcessDefinition of the subprocess.

    • createSubProcessInstance

      public PvmExecutionImpl createSubProcessInstance(PvmProcessDefinition processDefinition, String businessKey)
      Specified by:
      createSubProcessInstance in interface ActivityExecution
      Parameters:
      processDefinition - The PvmProcessDefinition of the subprocess.
      businessKey - the business key of the process instance
      See Also:

    • createSubProcessInstance

      public PvmExecutionImpl createSubProcessInstance(PvmProcessDefinition processDefinition, String businessKey, String caseInstanceId)
      Specified by:
      createSubProcessInstance in interface ActivityExecution
      Parameters:
      processDefinition - The PvmProcessDefinition of the subprocess.
      businessKey - the business key of the process instance
      caseInstanceId - the case instance id of the process instance
      See Also:

    • newExecution

      protected abstract PvmExecutionImpl newExecution()

    • createSubCaseInstance

      public abstract CmmnExecution createSubCaseInstance(CmmnCaseDefinition caseDefinition)
      Description copied from interface: ActivityExecution

      Creates a new sub case instance.

      This execution will be the super execution of the created sub case instance.

      Specified by:
      createSubCaseInstance in interface ActivityExecution
      Parameters:
      caseDefinition - The CmmnCaseDefinition of the sub case instance.

    • createSubCaseInstance

      public abstract CmmnExecution createSubCaseInstance(CmmnCaseDefinition caseDefinition, String businessKey)
      Description copied from interface: ActivityExecution

      Creates a new sub case instance.

      This execution will be the super execution of the created sub case instance.

      Specified by:
      createSubCaseInstance in interface ActivityExecution
      Parameters:
      caseDefinition - The CmmnCaseDefinition of the sub case instance.
      businessKey - The businessKey to be set on sub case instance.

    • initialize

      public abstract void initialize()

    • initializeTimerDeclarations

      public abstract void initializeTimerDeclarations()

    • executeIoMapping

      public void executeIoMapping()

    • start

      public void start()
      Specified by:
      start in interface PvmProcessInstance

    • start

      public void start(Map<String,Object> variables)
      Specified by:
      start in interface PvmProcessInstance

    • startWithFormProperties

      public void startWithFormProperties(VariableMap formProperties)

    • start

      protected void start(Map<String,Object> variables, VariableMap formProperties)

    • startWithoutExecuting

      public void startWithoutExecuting(Map<String,Object> variables)
      perform starting behavior but don't execute the initial activity
      Parameters:
      variables - the variables which are used for the start

    • fireHistoricProcessStartEvent

      public abstract void fireHistoricProcessStartEvent()

    • destroy

      public void destroy()
      Specified by:
      destroy in interface ActivityExecution

    • destroy

      public void destroy(boolean alwaysSkipIoMappings)
      Parameters:
      alwaysSkipIoMappings - set to true to always skip IO mappings, regardless of internal state of execution (=> CoreExecution.isSkipIoMappings())

    • removeAllTasks

      public void removeAllTasks()

    • removeEventScopes

      protected void removeEventScopes()

    • clearScope

      public void clearScope(String reason, boolean skipCustomListeners, boolean skipIoMappings, boolean externallyTerminated)

    • interrupt

      public void interrupt(String reason)
      Interrupts an execution
      Specified by:
      interrupt in interface ActivityExecution

    • interrupt

      public void interrupt(String reason, boolean skipCustomListeners, boolean skipIoMappings, boolean externallyTerminated)

    • end

      public void end(boolean completeScope)
      Ends an execution. Invokes end listeners for the current activity and notifies the flow scope execution of this happening which may result in the flow scope ending.
      Specified by:
      end in interface ActivityExecution
      Parameters:
      completeScope - true if ending the execution contributes to completing the BPMN 2.0 scope

    • endCompensation

      public void endCompensation()
      Description copied from interface: ActivityExecution
      Execution finished compensation. Removes this execution and notifies listeners.
      Specified by:
      endCompensation in interface ActivityExecution

    • propagateEnd

      public void propagateEnd()

      Precondition: execution is already ended but this has not been propagated yet.

      Propagates the ending of this execution to the flowscope execution; currently only supports the process instance execution

    • remove

      public void remove()
      Specified by:
      remove in interface ActivityExecution

    • isRemoved

      public boolean isRemoved()

    • createConcurrentExecution

      public PvmExecutionImpl createConcurrentExecution()

    • tryPruneLastConcurrentChild

      public boolean tryPruneLastConcurrentChild()
      Specified by:
      tryPruneLastConcurrentChild in interface ActivityExecution

    • deleteCascade

      public void deleteCascade(String deleteReason)
      Specified by:
      deleteCascade in interface PvmProcessInstance

    • deleteCascade

      public void deleteCascade(String deleteReason, boolean skipCustomListeners, boolean skipIoMappings)

    • deleteCascade

      public void deleteCascade(String deleteReason, boolean skipCustomListeners, boolean skipIoMappings, boolean externallyTerminated, boolean skipSubprocesses)

    • executeEventHandlerActivity

      public void executeEventHandlerActivity(ActivityImpl eventHandlerActivity)

    • getReplacedBy

      public abstract PvmExecutionImpl getReplacedBy()

      Returns an execution that has replaced this execution for executing activities in their shared scope.

      Invariant: this execution and getReplacedBy() execute in the same scope.

    • resolveReplacedBy

      public PvmExecutionImpl resolveReplacedBy()
      Instead of getReplacedBy(), which returns the execution that this execution was directly replaced with, this resolves the chain of replacements (i.e. in the case the replacedBy execution itself was replaced again)

    • hasReplacedParent

      public boolean hasReplacedParent()

    • isReplacedByParent

      public boolean isReplacedByParent()

    • replace

      public void replace(PvmExecutionImpl execution)

      Replace an execution by this execution. The replaced execution has a pointer (getReplacedBy()) to this execution. This pointer is maintained until the replaced execution is removed or this execution is removed/ended.

      This is used for two cases: Execution tree expansion and execution tree compaction

      • expansion: Before: 
               -------
       |  e1 |  scope
       -------
        After: 
               -------
       |  e1 |  scope
       -------
          |
       -------
       |  e2 |  cc (no scope)
       -------
        e2 replaces e1: it should receive all entities associated with the activity currently executed by e1; these are tasks, (local) variables, jobs (specific for the activity, not the scope)
      • compaction: Before: 
               -------
       |  e1 |  scope
       -------
          |
       -------
       |  e2 |  cc (no scope)
       -------
        After: 
               -------
       |  e1 |  scope
       -------
        e1 replaces e2: it should receive all entities associated with the activity currently executed by e2; these are tasks, (all) variables, all jobs
      See Also:

    • onConcurrentExpand

      public void onConcurrentExpand(PvmExecutionImpl scopeExecution)
      Callback on tree expansion when this execution is used as the concurrent execution where the argument's children become a subordinate to. Note that this case is not the inverse of replace because replace has the semantics that the replacing execution can be used to continue execution of this execution's activity instance.

    • signal

      public void signal(String signalName, Object signalData)
      Specified by:
      signal in interface ActivityExecution
      Specified by:
      signal in interface PvmExecution

    • take

      public void take()

    • executeActivity

      public void executeActivity(PvmActivity activity)
      Execute an activity which is not contained in normal flow (having no incoming sequence flows). Cannot be called for activities contained in normal flow.

      First, the ActivityStartBehavior is evaluated. In case the start behavior is not ActivityStartBehavior.DEFAULT, the corresponding start behavior is executed before executing the activity.

      For a given activity, the execution on which this method must be called depends on the type of the start behavior:

      Specified by:
      executeActivity in interface ActivityExecution
      Parameters:
      activity - the activity to start

    • executeActivitiesConcurrent

      public void executeActivitiesConcurrent(List<PvmActivity> activityStack, PvmActivity targetActivity, PvmTransition targetTransition, Map<String,Object> variables, Map<String,Object> localVariables, boolean skipCustomListeners, boolean skipIoMappings)
      Instantiates the given activity stack under this execution. Sets the variables for the execution responsible to execute the most deeply nested activity.
      Parameters:
      activityStack - The most deeply nested activity is the last element in the list

    • instantiateScopes

      public Map<PvmActivity,PvmExecutionImpl> instantiateScopes(List<PvmActivity> activityStack, boolean skipCustomListeners, boolean skipIoMappings)
      Instantiates the given set of activities and returns the execution for the bottom-most activity

    • executeActivities

      public void executeActivities(List<PvmActivity> activityStack, PvmActivity targetActivity, PvmTransition targetTransition, Map<String,Object> variables, Map<String,Object> localVariables, boolean skipCustomListeners, boolean skipIoMappings)
      Instantiates the given activity stack. Uses this execution to execute the highest activity in the stack. Sets the variables for the execution responsible to execute the most deeply nested activity.
      Parameters:
      activityStack - The most deeply nested activity is the last element in the list

    • findInactiveConcurrentExecutions

      public List<ActivityExecution> findInactiveConcurrentExecutions(PvmActivity activity)
      Description copied from interface: ActivityExecution
      Retrieves all executions which are concurrent and inactive at the given activity.
      Specified by:
      findInactiveConcurrentExecutions in interface ActivityExecution

    • findInactiveChildExecutions

      public List<ActivityExecution> findInactiveChildExecutions(PvmActivity activity)
      Specified by:
      findInactiveChildExecutions in interface ActivityExecution

    • getAllChildExecutions

      protected List<PvmExecutionImpl> getAllChildExecutions()

    • leaveActivityViaTransition

      public void leaveActivityViaTransition(PvmTransition outgoingTransition)
      Specified by:
      leaveActivityViaTransition in interface ActivityExecution

    • leaveActivityViaTransitions

      public void leaveActivityViaTransitions(List<PvmTransition> _transitions, List<? extends ActivityExecution> _recyclableExecutions)
      Description copied from interface: ActivityExecution
      Takes the given outgoing transitions, and potentially reusing the given list of executions that were previously joined.
      Specified by:
      leaveActivityViaTransitions in interface ActivityExecution

    • removeVariablesLocalInternal

      protected abstract void removeVariablesLocalInternal()

    • isActive

      public boolean isActive(String activityId)

    • inactivate

      public void inactivate()
      Description copied from interface: ActivityExecution
      Inactivates this execution. This is useful for example in a join: the execution still exists, but it is not longer active.
      Specified by:
      inactivate in interface ActivityExecution

    • getExecutions

      public abstract List<? extends PvmExecutionImpl> getExecutions()
      Description copied from interface: ActivityExecution
      returns the list of execution of which this execution the parent of. This is a copy of the actual list, so a modification has no direct effect.
      Specified by:
      getExecutions in interface ActivityExecution

    • getExecutionsAsCopy

      public abstract List<? extends PvmExecutionImpl> getExecutionsAsCopy()

    • getNonEventScopeExecutions

      public List<? extends PvmExecutionImpl> getNonEventScopeExecutions()
      Description copied from interface: ActivityExecution
      returns child executions that are not event scope executions.
      Specified by:
      getNonEventScopeExecutions in interface ActivityExecution

    • getEventScopeExecutions

      public List<? extends PvmExecutionImpl> getEventScopeExecutions()

    • findExecution

      public PvmExecutionImpl findExecution(String activityId)
      Specified by:
      findExecution in interface PvmProcessInstance

    • findExecutions

      public List<PvmExecution> findExecutions(String activityId)
      Specified by:
      findExecutions in interface PvmProcessInstance

    • collectExecutions

      protected void collectExecutions(String activityId, List<PvmExecution> executions)

    • findActiveActivityIds

      public List<String> findActiveActivityIds()
      Specified by:
      findActiveActivityIds in interface PvmProcessInstance

    • collectActiveActivityIds

      protected void collectActiveActivityIds(List<String> activeActivityIds)

    • getProcessBusinessKey

      public String getProcessBusinessKey()
      Description copied from interface: DelegateExecution
      The business key for the process instance this execution is associated with.
      Specified by:
      getProcessBusinessKey in interface DelegateExecution

    • setProcessBusinessKey

      public void setProcessBusinessKey(String businessKey)
      Description copied from interface: DelegateExecution
      Configure a business key on the process instance this execution is associated with.
      Specified by:
      setProcessBusinessKey in interface DelegateExecution
      Parameters:
      businessKey - the new business key

    • getBusinessKey

      public String getBusinessKey()
      Description copied from interface: BaseDelegateExecution
      The business key for the root execution (e.g. process instance).
      Specified by:
      getBusinessKey in interface BaseDelegateExecution

    • setProcessDefinition

      public void setProcessDefinition(ProcessDefinitionImpl processDefinition)

    • getProcessDefinition

      public ProcessDefinitionImpl getProcessDefinition()

    • getProcessInstance

      public abstract PvmExecutionImpl getProcessInstance()
      ensures initialization and returns the process instance.
      Specified by:
      getProcessInstance in interface DelegateExecution

    • setProcessInstance

      public abstract void setProcessInstance(PvmExecutionImpl pvmExecutionImpl)

    • getCaseInstanceId

      public String getCaseInstanceId()

    • setCaseInstanceId

      public void setCaseInstanceId(String caseInstanceId)

    • getActivity

      public ActivityImpl getActivity()
      ensures initialization and returns the activity
      Specified by:
      getActivity in interface ActivityExecution
      Specified by:
      getActivity in interface PvmExecution

    • getActivityId

      public String getActivityId()

    • getCurrentActivityName

      public String getCurrentActivityName()
      Description copied from interface: DelegateExecution
      Gets the name of the current activity.
      Specified by:
      getCurrentActivityName in interface DelegateExecution

    • getCurrentActivityId

      public String getCurrentActivityId()
      Description copied from interface: DelegateExecution
      Gets the id of the current activity.
      Specified by:
      getCurrentActivityId in interface DelegateExecution

    • setActivity

      public void setActivity(PvmActivity activity)
      Specified by:
      setActivity in interface ActivityExecution

    • enterActivityInstance

      public void enterActivityInstance()
      Description copied from interface: ActivityExecution
      invoked to notify the execution that a new activity instance is started
      Specified by:
      enterActivityInstance in interface ActivityExecution

    • activityInstanceStarting

      public void activityInstanceStarting()

    • activityInstanceStarted

      public void activityInstanceStarted()

    • activityInstanceDone

      public void activityInstanceDone()

    • activityInstanceEndListenerFailure

      public void activityInstanceEndListenerFailure()

    • generateActivityInstanceId

      protected abstract String generateActivityInstanceId(String activityId)

    • leaveActivityInstance

      public void leaveActivityInstance()
      Description copied from interface: ActivityExecution
      invoked to notify the execution that an activity instance is ended.
      Specified by:
      leaveActivityInstance in interface ActivityExecution

    • getParentActivityInstanceId

      public String getParentActivityInstanceId()
      Description copied from interface: ActivityExecution
      return the Id of the parent activity instance currently executed by this execution
      Specified by:
      getParentActivityInstanceId in interface ActivityExecution
      Specified by:
      getParentActivityInstanceId in interface DelegateExecution

    • setActivityInstanceId

      public void setActivityInstanceId(String activityInstanceId)
      Specified by:
      setActivityInstanceId in interface ActivityExecution

    • getActivityInstanceId

      public String getActivityInstanceId()
      Description copied from interface: ActivityExecution
      return the Id of the activity instance currently executed by this execution
      Specified by:
      getActivityInstanceId in interface ActivityExecution
      Specified by:
      getActivityInstanceId in interface DelegateExecution

    • getParent

      public abstract PvmExecutionImpl getParent()
      ensures initialization and returns the parent
      Specified by:
      getParent in interface ActivityExecution

    • getParentId

      public String getParentId()
      Description copied from interface: DelegateExecution
      Gets the id of the parent of this execution. If null, the execution represents a process-instance.
      Specified by:
      getParentId in interface DelegateExecution

    • hasChildren

      public boolean hasChildren()
      Specified by:
      hasChildren in interface ActivityExecution
      Returns:
      true if this execution has child executions (event scope executions or not)

    • setParent

      public void setParent(PvmExecutionImpl parent)
      Sets the execution's parent and updates the old and new parents' set of child executions

    • setParentExecution

      public abstract void setParentExecution(PvmExecutionImpl parent)
      Use #setParent to also update the child execution sets

    • getSuperExecution

      public abstract PvmExecutionImpl getSuperExecution()
      Description copied from interface: DelegateExecution
      In case this delegate execution is the process instance execution and this process instance was started by a call activity, this method returns the execution which executed the call activity in the super process instance.
      Specified by:
      getSuperExecution in interface DelegateExecution
      Returns:
      the super execution or null.

    • setSuperExecution

      public abstract void setSuperExecution(PvmExecutionImpl superExecution)

    • getSubProcessInstance

      public abstract PvmExecutionImpl getSubProcessInstance()

    • setSubProcessInstance

      public abstract void setSubProcessInstance(PvmExecutionImpl subProcessInstance)

    • getSuperCaseExecution

      public abstract CmmnExecution getSuperCaseExecution()

    • setSuperCaseExecution

      public abstract void setSuperCaseExecution(CmmnExecution superCaseExecution)

    • getSubCaseInstance

      public abstract CmmnExecution getSubCaseInstance()

    • setSubCaseInstance

      public abstract void setSubCaseInstance(CmmnExecution subCaseInstance)

    • getScopeActivity

      protected ScopeImpl getScopeActivity()

    • isScope

      public boolean isScope()
      Description copied from interface: ActivityExecution
      Returns whether this execution is a scope.
      Specified by:
      isScope in interface ActivityExecution

    • setScope

      public void setScope(boolean isScope)
      Description copied from interface: ActivityExecution
      Changes whether this execution is a scope or not
      Specified by:
      setScope in interface ActivityExecution

    • findExecutionForFlowScope

      public PvmExecutionImpl findExecutionForFlowScope(PvmScope targetFlowScope)
      For a given target flow scope, this method returns the corresponding scope execution.

      Precondition: the execution is active and executing an activity. Can be invoked for scope and non scope executions.

      Specified by:
      findExecutionForFlowScope in interface ActivityExecution
      Parameters:
      targetFlowScope - scope activity or process definition for which the scope execution should be found
      Returns:
      the scope execution for the provided targetFlowScope

    • findExecutionForScope

      public PvmExecutionImpl findExecutionForScope(ScopeImpl currentScope, ScopeImpl targetScope)

    • createActivityExecutionMapping

      public Map<ScopeImpl,PvmExecutionImpl> createActivityExecutionMapping(ScopeImpl currentScope)

    • createActivityExecutionMapping

      public Map<ScopeImpl,PvmExecutionImpl> createActivityExecutionMapping()
      Description copied from interface: ActivityExecution
      Returns a mapping from scope activities to scope executions for all scopes that are ancestors of the activity currently executed by this execution. Assumption: the current execution is active and executing an activity (ActivityExecution.getActivity() is not null).
      Specified by:
      createActivityExecutionMapping in interface ActivityExecution

    • getFlowScopeExecution

      protected PvmExecutionImpl getFlowScopeExecution()

    • getFlowScope

      protected ScopeImpl getFlowScope()

    • createActivityExecutionMapping

      protected Map<ScopeImpl,PvmExecutionImpl> createActivityExecutionMapping(ScopeImpl currentScope, Map<ScopeImpl,PvmExecutionImpl> mapping)
      Creates an extended mapping based on this execution and the given existing mapping. Any entry mapping in mapping that corresponds to an ancestor scope of currentScope is reused.

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • getToStringIdentity

      protected String getToStringIdentity()

    • getVariableScopeKey

      public String getVariableScopeKey()
      Specified by:
      getVariableScopeKey in interface VariableScope
      Overrides:
      getVariableScopeKey in class AbstractVariableScope

    • getParentVariableScope

      public AbstractVariableScope getParentVariableScope()
      Specified by:
      getParentVariableScope in class AbstractVariableScope

    • setVariable

      public void setVariable(String variableName, Object value, String targetActivityId)
      Method to store variable in a specific scope identified by activity ID.
      Specified by:
      setVariable in interface DelegateExecution
      Parameters:
      variableName - - name of the variable
      value - - value of the variable
      targetActivityId - - activity ID which is associated with destination execution, if not existing - exception will be thrown

    • findExecutionForFlowScope

      protected PvmExecutionImpl findExecutionForFlowScope(String targetScopeId)
      Parameters:
      targetScopeId - - destination scope to be found in current execution tree
      Returns:
      execution with activity id corresponding to targetScopeId

    • getSequenceCounter

      public long getSequenceCounter()

    • setSequenceCounter

      public void setSequenceCounter(long sequenceCounter)

    • incrementSequenceCounter

      public void incrementSequenceCounter()

    • isExternallyTerminated

      public boolean isExternallyTerminated()

    • setExternallyTerminated

      public void setExternallyTerminated(boolean externallyTerminated)

    • getDeleteReason

      public String getDeleteReason()

    • setDeleteReason

      public void setDeleteReason(String deleteReason)

    • isDeleteRoot

      public boolean isDeleteRoot()

    • setDeleteRoot

      public void setDeleteRoot(boolean deleteRoot)

    • getTransition

      public TransitionImpl getTransition()
      Specified by:
      getTransition in interface ActivityExecution

    • getTransitionsToTake

      public List<PvmTransition> getTransitionsToTake()

    • setTransitionsToTake

      public void setTransitionsToTake(List<PvmTransition> transitionsToTake)

    • getCurrentTransitionId

      public String getCurrentTransitionId()
      Description copied from interface: DelegateExecution
      return the Id of the current transition
      Specified by:
      getCurrentTransitionId in interface DelegateExecution

    • setTransition

      public void setTransition(PvmTransition transition)

    • isConcurrent

      public boolean isConcurrent()
      Description copied from interface: ActivityExecution
      returns whether this execution is concurrent or not.
      Specified by:
      isConcurrent in interface ActivityExecution

    • setConcurrent

      public void setConcurrent(boolean isConcurrent)
      Description copied from interface: ActivityExecution
      changes the concurrent indicator on this execution.
      Specified by:
      setConcurrent in interface ActivityExecution

    • isActive

      public boolean isActive()
      Description copied from interface: ActivityExecution
      returns whether this execution is currently active.
      Specified by:
      isActive in interface ActivityExecution

    • setActive

      public void setActive(boolean isActive)
      Description copied from interface: ActivityExecution
      makes this execution active or inactive.
      Specified by:
      setActive in interface ActivityExecution

    • setEnded

      public void setEnded(boolean isEnded)
      Specified by:
      setEnded in interface ActivityExecution

    • isEnded

      public boolean isEnded()
      Description copied from interface: ActivityExecution
      returns whether this execution has ended or not.
      Specified by:
      isEnded in interface ActivityExecution
      Specified by:
      isEnded in interface PvmProcessInstance

    • isCanceled

      public boolean isCanceled()
      Description copied from interface: DelegateExecution
      Returns whether this execution has been canceled.
      Specified by:
      isCanceled in interface DelegateExecution

    • setCanceled

      public void setCanceled(boolean canceled)

    • isCompleteScope

      public boolean isCompleteScope()
      Description copied from interface: ActivityExecution
      Returns whether this execution completed the parent scope.
      Specified by:
      isCompleteScope in interface ActivityExecution

    • setCompleteScope

      public void setCompleteScope(boolean completeScope)

    • setPreserveScope

      public void setPreserveScope(boolean preserveScope)

    • isPreserveScope

      public boolean isPreserveScope()

    • getActivityInstanceState

      public int getActivityInstanceState()

    • isInState

      public boolean isInState(ActivityInstanceState state)

    • hasFailedOnEndListeners

      public boolean hasFailedOnEndListeners()
      Overrides:
      hasFailedOnEndListeners in class CoreExecution

    • isEventScope

      public boolean isEventScope()

    • setEventScope

      public void setEventScope(boolean isEventScope)

    • getScopeInstantiationContext

      public ScopeInstantiationContext getScopeInstantiationContext()

    • disposeScopeInstantiationContext

      public void disposeScopeInstantiationContext()

    • getNextActivity

      public PvmActivity getNextActivity()
      Description copied from interface: ActivityExecution
      An activity which is to be started next.
      Specified by:
      getNextActivity in interface ActivityExecution

    • isProcessInstanceExecution

      public boolean isProcessInstanceExecution()
      Description copied from interface: ActivityExecution
      returns whether this execution is a process instance or not.
      Specified by:
      isProcessInstanceExecution in interface ActivityExecution

    • setStartContext

      public void setStartContext(ScopeInstantiationContext startContext)

    • setIgnoreAsync

      public void setIgnoreAsync(boolean ignoreAsync)
      Specified by:
      setIgnoreAsync in interface ActivityExecution

    • isIgnoreAsync

      public boolean isIgnoreAsync()

    • setStarting

      public void setStarting(boolean isStarting)

    • isStarting

      public boolean isStarting()

    • isProcessInstanceStarting

      public boolean isProcessInstanceStarting()

    • setProcessInstanceStarting

      public void setProcessInstanceStarting(boolean starting)

    • setNextActivity

      public void setNextActivity(PvmActivity nextActivity)

    • getParentScopeExecution

      public PvmExecutionImpl getParentScopeExecution(boolean considerSuperExecution)

    • delayEvent

      public void delayEvent(PvmExecutionImpl targetScope, VariableEvent variableEvent)
      Delays a given variable event with the given target scope.
      Parameters:
      targetScope - the target scope of the variable event
      variableEvent - the variable event which should be delayed

    • delayEvent

      public void delayEvent(DelayedVariableEvent delayedVariableEvent)
      Delays and stores the given DelayedVariableEvent on the process instance.
      Parameters:
      delayedVariableEvent - the DelayedVariableEvent which should be store on the process instance

    • getDelayedEvents

      public List<DelayedVariableEvent> getDelayedEvents()
      The current delayed variable events.
      Returns:
      a list of DelayedVariableEvent objects

    • clearDelayedEvents

      public void clearDelayedEvents()
      Cleares the current delayed variable events.

    • dispatchDelayedEventsAndPerformOperation

      public void dispatchDelayedEventsAndPerformOperation(PvmAtomicOperation atomicOperation)
      Dispatches the current delayed variable events and performs the given atomic operation if the current state was not changed.
      Parameters:
      atomicOperation - the atomic operation which should be executed

    • dispatchDelayedEventsAndPerformOperation

      public void dispatchDelayedEventsAndPerformOperation(Callback<PvmExecutionImpl,Void> continuation)
      Dispatches the current delayed variable events and performs the given atomic operation if the current state was not changed.
      Parameters:
      continuation - the atomic operation continuation which should be executed

    • continueIfExecutionDoesNotAffectNextOperation

      public void continueIfExecutionDoesNotAffectNextOperation(Callback<PvmExecutionImpl,Void> dispatching, Callback<PvmExecutionImpl,Void> continuation, PvmExecutionImpl execution)
      Executes the given depending operations with the given execution. The execution state will be checked with the help of the activity instance id and activity id of the execution before and after the dispatching callback call. If the id's are not changed the continuation callback is called.
      Parameters:
      dispatching - the callback to dispatch the variable events
      continuation - the callback to continue with the next atomic operation
      execution - the execution which is used for the execution

    • continueExecutionIfNotCanceled

      protected void continueExecutionIfNotCanceled(Callback<PvmExecutionImpl,Void> continuation, PvmExecutionImpl execution)

    • dispatchScopeEvents

      protected void dispatchScopeEvents(PvmExecutionImpl execution)
      Dispatches the current delayed variable events on the scope of the given execution.
      Parameters:
      execution - the execution on which scope the delayed variable should be dispatched

    • initActivityIds

      protected void initActivityIds(List<DelayedVariableEvent> delayedEvents, Map<PvmExecutionImpl,String> activityInstanceIds, Map<PvmExecutionImpl,String> activityIds)
      Initializes the given maps with the target scopes and current activity id's and activity instance id's.
      Parameters:
      delayedEvents - the delayed events which contains the information about the target scope
      activityInstanceIds - the map which maps target scope to activity instance id
      activityIds - the map which maps target scope to activity id

    • createIncident

      public Incident createIncident(String incidentType, String configuration)
      Returns the newest incident in this execution
      Specified by:
      createIncident in interface DelegateExecution
      Parameters:
      incidentType - the type of new incident
      configuration - configuration of the incident
      Returns:
      new incident

    • createIncident

      public Incident createIncident(String incidentType, String configuration, String message)
      Description copied from interface: DelegateExecution
      Create an incident associated with this execution
      Specified by:
      createIncident in interface DelegateExecution
      Parameters:
      incidentType - the type of incident
      Returns:
      a new incident

    • createIncidentContext

      protected IncidentContext createIncidentContext(String configuration)

    • resolveIncident

      public void resolveIncident(String incidentId)
      Resolves an incident with given id.
      Specified by:
      resolveIncident in interface DelegateExecution
      Parameters:
      incidentId -

    • findIncidentHandler

      public IncidentHandler findIncidentHandler(String incidentType)

    • isExecutingScopeLeafActivity

      public boolean isExecutingScopeLeafActivity()

    • isAsyncAfterScopeWithoutTransition

      public boolean isAsyncAfterScopeWithoutTransition()
      This case is special, because the execution tree is different if an async after activity is left via transition (case 1) or not (case 2). In case 1, when the execution becomes async, the scope execution is already removed. In case 2 it is not.
      Returns:
      true if
      • the execution is in asyncAfter state and completes
      • leaves a scope activity
      • completes the parent scope (i.e. does not leave via a transition but propagates control to the parent)