Java ScopeImpl.getActivityBehavior方法代码示例

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入方法依赖的package包/类
/**
 * Returns true if the given execution is in a compensation-throwing activity but there is no dedicated scope execution
 * in the given mapping.
 */
public static boolean isCompensationThrowing(PvmExecutionImpl execution, Map<ScopeImpl, PvmExecutionImpl> activityExecutionMapping) {
  if (CompensationBehavior.isCompensationThrowing(execution)) {
    ScopeImpl compensationThrowingActivity = execution.getActivity();

    if (compensationThrowingActivity.isScope()) {
      return activityExecutionMapping.get(compensationThrowingActivity) ==
          activityExecutionMapping.get(compensationThrowingActivity.getFlowScope());
    }
    else {
      // for transaction sub processes with cancel end events, the compensation throwing execution waits in the boundary event, not in the end
      // event; cancel boundary events are currently not scope
      return compensationThrowingActivity.getActivityBehavior() instanceof CancelBoundaryEventActivityBehavior;
    }
  }
  else {
    return false;
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入方法依赖的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.pvm.process.ScopeImpl; //导入方法依赖的package包/类
protected boolean isMiBody(ScopeImpl scope) {
  return scope.getActivityBehavior() instanceof MultiInstanceActivityBehavior;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入方法依赖的package包/类
protected boolean isMultiInstance(ScopeImpl flowScope) {
  return flowScope.getActivityBehavior() instanceof MultiInstanceActivityBehavior;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入方法依赖的package包/类
protected boolean isMultiInstance(ScopeImpl scope) {
  return scope.getActivityBehavior() instanceof MultiInstanceActivityBehavior;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入方法依赖的package包/类
@Override
public void handle(MigratingInstanceParseContext parseContext, ActivityInstance element) {
  MigratingActivityInstance migratingInstance = null;

  MigrationInstruction applyingInstruction = parseContext.getInstructionFor(element.getActivityId());
  ScopeImpl sourceScope = null;
  ScopeImpl targetScope = null;
  ExecutionEntity representativeExecution = parseContext.getMapping().getExecution(element);

  if (element.getId().equals(element.getProcessInstanceId())) {
    sourceScope = parseContext.getSourceProcessDefinition();
    targetScope = parseContext.getTargetProcessDefinition();
  }
  else {
    sourceScope = parseContext.getSourceProcessDefinition().findActivity(element.getActivityId());

    if (applyingInstruction != null) {
      String activityId = applyingInstruction.getTargetActivityId();
      targetScope = parseContext.getTargetProcessDefinition().findActivity(activityId);
    }
  }

  migratingInstance = parseContext.getMigratingProcessInstance()
      .addActivityInstance(
        applyingInstruction,
        element,
        sourceScope,
        targetScope,
        representativeExecution);

  MigratingActivityInstance parentInstance = parseContext.getMigratingActivityInstanceById(element.getParentActivityInstanceId());

  if (parentInstance != null) {
    migratingInstance.setParent(parentInstance);
  }

  CoreActivityBehavior<?> sourceActivityBehavior = sourceScope.getActivityBehavior();
  if (sourceActivityBehavior instanceof MigrationObserverBehavior) {
    ((MigrationObserverBehavior) sourceActivityBehavior).onParseMigratingInstance(parseContext, migratingInstance);
  }

  parseContext.submit(migratingInstance);

  parseTransitionInstances(parseContext, migratingInstance);

  parseDependentInstances(parseContext, migratingInstance);
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入方法依赖的package包/类
/**
 * Cannot create more than inner instance in a sequential MI construct
 */
protected boolean supportsConcurrentChildInstantiation(ScopeImpl flowScope) {
  CoreActivityBehavior<?> behavior = flowScope.getActivityBehavior();
  return behavior == null || !(behavior instanceof SequentialMultiInstanceActivityBehavior);
}