import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public InstantiationStack getInstantiationStack() {

  if (instantiationStack == null) {
    FlowScopeWalker flowScopeWalker = new FlowScopeWalker(initial.getFlowScope());
    ScopeCollector scopeCollector = new ScopeCollector();
    flowScopeWalker.addPreVisitor(scopeCollector).walkWhile(new ReferenceWalker.WalkCondition<ScopeImpl>() {
      public boolean isFulfilled(ScopeImpl element) {
        return element == null || element == initial.getProcessDefinition();
      }
    });

    List<PvmActivity> scopeActivities = (List) scopeCollector.getScopes();
    Collections.reverse(scopeActivities);

    instantiationStack = new InstantiationStack(scopeActivities, initial, null);
  }

  return instantiationStack;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
/**
 * Returns a list of flow scopes from the given scope until a scope is reached that is already present in the given
 * {@link MigratingScopeInstanceBranch} (exclusive). The order of the returned list is top-down, i.e. the highest scope
 * is the first element of the list.
 */
protected List<ScopeImpl> collectNonExistingFlowScopes(ScopeImpl scope, final MigratingScopeInstanceBranch migratingExecutionBranch) {
  FlowScopeWalker walker = new FlowScopeWalker(scope);
  final List<ScopeImpl> result = new LinkedList<ScopeImpl>();
  walker.addPreVisitor(new TreeVisitor<ScopeImpl>() {

    @Override
    public void visit(ScopeImpl obj) {
      result.add(0, obj);
    }
  });

  walker.walkWhile(new ReferenceWalker.WalkCondition<ScopeImpl>() {

    @Override
    public boolean isFulfilled(ScopeImpl element) {
      return migratingExecutionBranch.hasInstance(element);
    }
  });

  return result;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public MigratingTransitionInstance addTransitionInstance(
    MigrationInstruction migrationInstruction,
    TransitionInstance transitionInstance,
    ScopeImpl sourceScope,
    ScopeImpl targetScope,
    ExecutionEntity asyncExecution) {

  MigratingTransitionInstance migratingTransitionInstance = new MigratingTransitionInstance(
      transitionInstance,
      migrationInstruction,
      sourceScope,
      targetScope,
      asyncExecution);

  migratingTransitionInstances.add(migratingTransitionInstance);

  return migratingTransitionInstance;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public MigratingEventScopeInstance addEventScopeInstance(
    MigrationInstruction migrationInstruction,
    ExecutionEntity eventScopeExecution,
    ScopeImpl sourceScope,
    ScopeImpl targetScope,
    MigrationInstruction eventSubscriptionInstruction,
    EventSubscriptionEntity eventSubscription,
    ScopeImpl eventSubscriptionSourceScope,
    ScopeImpl eventSubscriptionTargetScope) {

  MigratingEventScopeInstance compensationInstance = new MigratingEventScopeInstance(
      migrationInstruction,
      eventScopeExecution,
      sourceScope,
      targetScope,
      eventSubscriptionInstruction,
      eventSubscription,
      eventSubscriptionSourceScope,
      eventSubscriptionTargetScope);

  migratingEventScopeInstances.add(compensationInstance);

  return compensationInstance;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
protected void instantiateScopes(
    MigratingScopeInstance ancestorScopeInstance,
    MigratingScopeInstanceBranch executionBranch,
    List<ScopeImpl> scopesToInstantiate) {

  if (scopesToInstantiate.isEmpty()) {
    return;
  }

  // must always be an activity instance
  MigratingActivityInstance ancestorActivityInstance = (MigratingActivityInstance) ancestorScopeInstance;

  ExecutionEntity newParentExecution = ancestorActivityInstance.createAttachableExecution();

  Map<PvmActivity, PvmExecutionImpl> createdExecutions =
      newParentExecution.instantiateScopes((List) scopesToInstantiate, skipCustomListeners, skipIoMappings);

  for (ScopeImpl scope : scopesToInstantiate) {
    ExecutionEntity createdExecution = (ExecutionEntity) createdExecutions.get(scope);
    createdExecution.setActivity(null);
    createdExecution.setActive(false);
    executionBranch.visited(new MigratingActivityInstance(scope, createdExecution));
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public MigratingActivityInstance addActivityInstance(
    MigrationInstruction migrationInstruction,
    ActivityInstance activityInstance,
    ScopeImpl sourceScope,
    ScopeImpl targetScope,
    ExecutionEntity scopeExecution) {

  MigratingActivityInstance migratingActivityInstance = new MigratingActivityInstance(
      activityInstance,
      migrationInstruction,
      sourceScope,
      targetScope,
      scopeExecution);

  migratingActivityInstances.add(migratingActivityInstance);

  if (processInstanceId.equals(activityInstance.getId())) {
    rootInstance = migratingActivityInstance;
  }

  return migratingActivityInstance;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void handle(MigratingInstanceParseContext parseContext, MigratingTransitionInstance transitionInstance, List<JobEntity> elements) {

  for (JobEntity job : elements) {
    if (!isAsyncContinuation(job)) {
      continue;
    }

    ScopeImpl targetScope = transitionInstance.getTargetScope();
    if (targetScope != null) {
      JobDefinitionEntity targetJobDefinitionEntity = parseContext.getTargetJobDefinition(transitionInstance.getTargetScope().getId(), job.getJobHandlerType());

      MigratingAsyncJobInstance migratingJobInstance =
          new MigratingAsyncJobInstance(job, targetJobDefinitionEntity, transitionInstance.getTargetScope());

      transitionInstance.setDependentJobInstance(migratingJobInstance);
      parseContext.submit(migratingJobInstance);
    }

    parseContext.consume(job);
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
/**
 * Hooks listeners to assignment and creation of tasks.
 * @param userTaskElement task to hook to
 * @param scope a BPMN scope
 * @param activity an Activity scope
 */
@Override
public void parseUserTask(Element userTaskElement, ScopeImpl scope, ActivityImpl activity) {
    UserTaskActivityBehavior activityBehavior = (UserTaskActivityBehavior) activity.getActivityBehavior();
    TaskDefinition taskDefinition = activityBehavior.getTaskDefinition();
    addTaskAssignmentListeners(taskDefinition);
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void preInit(final ProcessEngineConfigurationImpl configuration) {
  new ShowcaseSetup().run();

  customPreBPMNParseListeners(configuration).add(new AbstractBpmnParseListener() {
    @Override
    public void parseUserTask(final Element userTaskElement, final ScopeImpl scope, final ActivityImpl activity) {
      taskDefinition(activity).addTaskListener(EVENTNAME_CREATE, new SkillBasedRoutingListener());
    }
  });
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void parseSequenceFlow(Element sequenceFlowElement, ScopeImpl scopeElement,
        org.camunda.bpm.engine.impl.pvm.process.TransitionImpl transition) {

    final PathCoverageExecutionListener pathCoverageExecutionListener = new PathCoverageExecutionListener(
            coverageTestRunState);
    transition.addListener(ExecutionListener.EVENTNAME_TAKE, pathCoverageExecutionListener);

}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scope,
        org.camunda.bpm.engine.impl.pvm.process.ActivityImpl activity) {

    final IntermediateEventExecutionListener startListener = new IntermediateEventExecutionListener(
            coverageTestRunState);
    activity.addListener(ExecutionListener.EVENTNAME_START, startListener);

    final IntermediateEventExecutionListener endListener = new IntermediateEventExecutionListener(
            coverageTestRunState);
    activity.addListener(ExecutionListener.EVENTNAME_END, endListener);
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public static boolean eventSubprocessConcurrentChildExecutionEnded(ActivityExecution scopeExecution, ActivityExecution endedExecution) {
  boolean performLegacyBehavior = isLegacyBehaviorRequired(endedExecution);

  if(performLegacyBehavior) {
    LOG.endConcurrentExecutionInEventSubprocess();
    // notify the grandparent flow scope in a similar way PvmAtomicOperationAcitivtyEnd does
    ScopeImpl flowScope = endedExecution.getActivity().getFlowScope();
    if (flowScope != null) {
      flowScope = flowScope.getFlowScope();

      if (flowScope != null) {
        if (flowScope == endedExecution.getActivity().getProcessDefinition()) {
          endedExecution.remove();
          scopeExecution.tryPruneLastConcurrentChild();
          scopeExecution.forceUpdate();
        }
        else {
          PvmActivity flowScopeActivity = (PvmActivity) flowScope;

          ActivityBehavior activityBehavior = flowScopeActivity.getActivityBehavior();
          if (activityBehavior instanceof CompositeActivityBehavior) {
            ((CompositeActivityBehavior) activityBehavior).concurrentChildExecutionEnded(scopeExecution, endedExecution);
          }
        }
      }
    }
  }

  return performLegacyBehavior;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void initializeTimerDeclarations() {
  LOG.initializeTimerDeclaration(this);
  ScopeImpl scope = getScopeActivity();
  Collection<TimerDeclarationImpl> timerDeclarations = TimerDeclarationImpl.getDeclarationsForScope(scope).values();
  for (TimerDeclarationImpl timerDeclaration : timerDeclarations) {
    timerDeclaration.createTimerInstance(this);
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scope, ActivityImpl activity) {
  String type = activity.getProperties().get(BpmnProperties.TYPE);
  if (type != null && type.equals(INTERMEDIATE_TIMER)) {
    this.setFailedJobRetryTimeCycleValue(intermediateEventElement, activity);
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public Set<ExecutionEntity> getExecutions(ScopeImpl activity) {
  Set<ExecutionEntity> executionsForActivity = activityExecutionMapping.get(activity);
  if (executionsForActivity == null) {
    executionsForActivity = new HashSet<ExecutionEntity>();
    activityExecutionMapping.put(activity, executionsForActivity);
  }

  return executionsForActivity;
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public MigratingTransitionInstance(
    TransitionInstance transitionInstance,
    MigrationInstruction migrationInstruction,
    ScopeImpl sourceScope,
    ScopeImpl targetScope,
    ExecutionEntity asyncExecution) {
  this.transitionInstance = transitionInstance;
  this.migrationInstruction = migrationInstruction;
  this.sourceScope = sourceScope;
  this.targetScope = targetScope;
  this.currentScope = sourceScope;
  this.representativeExecution = asyncExecution;
  this.activeState = representativeExecution.isActive();
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Override
public void validate(MigratingActivityInstance migratingInstance, MigratingProcessInstance migratingProcessInstance,
    MigratingActivityInstanceValidationReportImpl instanceReport) {

  ScopeImpl sourceScope = migratingInstance.getSourceScope();

  if (sourceScope != sourceScope.getProcessDefinition()) {
    ActivityImpl sourceActivity = (ActivityImpl) migratingInstance.getSourceScope();

    if (!SupportedActivityValidator.INSTANCE.isSupportedActivity(sourceActivity)) {
      instanceReport.addFailure("The type of the source activity is not supported for activity instance migration");
    }
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
@Deployment(resources = "org/camunda/bpm/engine/test/bpmn/event/compensate/CompensateEventTest.compensationMiActivity.bpmn20.xml")
public void testParseCompensationHandlerOfMiActivity() {
  ActivityImpl miActivity = findActivityInDeployedProcessDefinition("undoBookHotel");
  ScopeImpl flowScope = miActivity.getFlowScope();

  assertEquals(ActivityTypes.MULTI_INSTANCE_BODY, flowScope.getProperty(BpmnParse.PROPERTYNAME_TYPE));
  assertEquals("bookHotel" + BpmnParse.MULTI_INSTANCE_BODY_ID_SUFFIX, ((ActivityImpl) flowScope).getActivityId());
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
public List<ValidatingMigrationInstruction> getInstructionsByTargetScope(ScopeImpl scope) {
  List<ValidatingMigrationInstruction> instructions = instructionsByTargetScope.get(scope);

  if (instructions == null) {
    return Collections.emptyList();
  }
  else {
    return instructions;
  }
}
 

import org.camunda.bpm.engine.impl.pvm.process.ScopeImpl; //导入依赖的package包/类
/**
 * Creates an emerged scope
 */
public MigratingEventScopeInstance(
    EventSubscriptionEntity eventSubscription,
    ExecutionEntity eventScopeExecution,
    ScopeImpl targetScope
    ) {
  this.migratingEventSubscription =
      new MigratingCompensationEventSubscriptionInstance(null, null, targetScope, eventSubscription);
  this.eventScopeExecution = eventScopeExecution;

  // compensation handlers (not boundary events)
  // or parent flow scopes
  this.targetScope = targetScope;
  this.currentScope = targetScope;
}