Java ExecutionEntity.getParent方法代码示例

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
protected void initActivityInstanceEvent(HistoricActivityInstanceEventEntity evt, ExecutionEntity execution, HistoryEventType eventType) {
  PvmScope eventSource = execution.getActivity();
  if (eventSource == null) {
    eventSource = (PvmScope) execution.getEventSource();
  }
  String activityInstanceId = execution.getActivityInstanceId();

  String parentActivityInstanceId = null;
  ExecutionEntity parentExecution = execution.getParent();

  if (parentExecution != null && CompensationBehavior.isCompensationThrowing(parentExecution) && execution.getActivity() != null) {
    parentActivityInstanceId = CompensationBehavior.getParentActivityInstanceId(execution);
  } else {
    parentActivityInstanceId = execution.getParentActivityInstanceId();
  }

  initActivityInstanceEvent(evt,
      execution,
      eventSource,
      activityInstanceId,
      parentActivityInstanceId,
      eventType);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
@Override
public void handle(MigratingInstanceParseContext parseContext, MigratingProcessElementInstance owningInstance, List<VariableInstanceEntity> variables) {

  ExecutionEntity representativeExecution = owningInstance.resolveRepresentativeExecution();

  for (VariableInstanceEntity variable : variables) {
    parseContext.consume(variable);
    boolean isConcurrentLocalInParentScope =
         (variable.getExecution() == representativeExecution.getParent() && variable.isConcurrentLocal())
      || representativeExecution.isConcurrent();
    owningInstance.addMigratingDependentInstance(new MigratingVariableInstance(variable, isConcurrentLocalInParentScope));
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
protected List<VariableInstanceEntity> collectActivityInstanceVariables(MigratingActivityInstance instance) {
  List<VariableInstanceEntity> variables = new ArrayList<VariableInstanceEntity>();
  ExecutionEntity representativeExecution = instance.resolveRepresentativeExecution();
  ExecutionEntity parentExecution = representativeExecution.getParent();

  // decide for representative execution and parent execution whether to none/all/concurrentLocal variables
  // belong to this activity instance
  boolean addAllRepresentativeExecutionVariables = instance.getSourceScope().isScope()
      || representativeExecution.isConcurrent();

  if (addAllRepresentativeExecutionVariables) {
    variables.addAll(representativeExecution.getVariablesInternal());
  }
  else {
    variables.addAll(getConcurrentLocalVariables(representativeExecution));
  }

  boolean addAnyParentExecutionVariables = parentExecution != null && instance.getSourceScope().isScope();
  if (addAnyParentExecutionVariables) {
    boolean addAllParentExecutionVariables = parentExecution.isConcurrent();

    if (addAllParentExecutionVariables) {
      variables.addAll(parentExecution.getVariablesInternal());
    }
    else {
      variables.addAll(getConcurrentLocalVariables(parentExecution));
    }
  }

  return variables;
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
@Override
public void attachState(MigratingScopeInstance owningActivityInstance) {
  ExecutionEntity representativeExecution = owningActivityInstance.resolveRepresentativeExecution();
  ScopeImpl currentScope = owningActivityInstance.getCurrentScope();

  ExecutionEntity newOwningExecution = representativeExecution;

  if (currentScope.isScope() && isConcurrentLocalInParentScope) {
    newOwningExecution = representativeExecution.getParent();
  }

  newOwningExecution.addVariableInternal(variable);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
@Override
public void detachState() {
  ExecutionEntity currentScopeExecution = resolveRepresentativeExecution();

  ExecutionEntity parentExecution = currentScopeExecution.getParent();
  currentScopeExecution.setParent(null);

  if (sourceScope.getActivityBehavior() instanceof CompositeActivityBehavior) {
    parentExecution.leaveActivityInstance();
  }

  getParent().destroyAttachableExecution(parentExecution);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
@Override
public void migrateState() {
  ExecutionEntity currentScopeExecution = resolveRepresentativeExecution();
  currentScopeExecution.setProcessDefinition(targetScope.getProcessDefinition());

  ExecutionEntity parentExecution = currentScopeExecution.getParent();

  if (parentExecution != null && parentExecution.isConcurrent()) {
    parentExecution.setProcessDefinition(targetScope.getProcessDefinition());
  }

  currentScope = targetScope;

  if (!targetScope.isScope()) {
    becomeNonScope();
    currentScopeExecution = resolveRepresentativeExecution();
  }

  if (isLeafActivity(targetScope)) {
    currentScopeExecution.setActivity((PvmActivity) targetScope);
  }

  if (sourceScope.getActivityBehavior() instanceof MigrationObserverBehavior) {
    ((MigrationObserverBehavior) sourceScope.getActivityBehavior()).migrateScope(currentScopeExecution);
  }

  migrateHistory(currentScopeExecution);
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
protected void handleChildRemovalInScope(ExecutionEntity removedExecution) {
  // TODO: the following should be closer to PvmAtomicOperationDeleteCascadeFireActivityEnd
  // (note though that e.g. boundary events expect concurrent executions to be preserved)
  //
  // Idea: attempting to prune and synchronize on the parent is the default behavior when
  // a concurrent child is removed, but scope activities implementing ModificationObserverBehavior
  // override this default (and therefore *must* take care of reorganization themselves)

  // notify the behavior that a concurrent execution has been removed

  // must be set due to deleteCascade behavior
  ActivityImpl activity = removedExecution.getActivity();
  if (activity == null) {
    return;
  }
  ScopeImpl flowScope = activity.getFlowScope();

  PvmExecutionImpl scopeExecution = removedExecution.getParentScopeExecution(false);
  PvmExecutionImpl executionInParentScope = removedExecution.isConcurrent() ? removedExecution : removedExecution.getParent();

  if (flowScope.getActivityBehavior() != null && flowScope.getActivityBehavior() instanceof ModificationObserverBehavior) {
    // let child removal be handled by the scope itself
    ModificationObserverBehavior behavior = (ModificationObserverBehavior) flowScope.getActivityBehavior();
    behavior.destroyInnerInstance(executionInParentScope);
  }
  else {
    if (executionInParentScope.isConcurrent()) {
      executionInParentScope.remove();
      scopeExecution.tryPruneLastConcurrentChild();
      scopeExecution.forceUpdate();
    }
  }
}
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
protected void addEventToScopeExecution(ExecutionEntity sourceScope, VariableEvent event) {

    // ignore events of variables that are not set in an execution
    ExecutionEntity sourceExecution = sourceScope;
    ExecutionEntity scopeExecution = sourceExecution.isScope() ? sourceExecution : sourceExecution.getParent();
    scopeExecution.delayEvent((ExecutionEntity) targetScope, event);

  }
 

import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity; //导入方法依赖的package包/类
@Override
public boolean isDetached() {
  ExecutionEntity representativeExecution = resolveRepresentativeExecution();
  return representativeExecution != representativeExecution.getProcessInstance()
    && representativeExecution.getParent() == null;
}