protected internal override void InstantiateScopes(MigratingScopeInstance ancestorScopeInstance, MigratingScopeInstanceBranch executionBranch, IList <ScopeImpl> scopesToInstantiate) { if (scopesToInstantiate.Count == 0) { return; } var ancestorScopeExecution = ancestorScopeInstance.ResolveRepresentativeExecution(); var parentExecution = ancestorScopeExecution; foreach (var scope in scopesToInstantiate) { var compensationScopeExecution = parentExecution.CreateExecution(); compensationScopeExecution.IsScope = true; compensationScopeExecution.IsEventScope = true; //compensationScopeExecution.setActivity((IPvmActivity) scope); compensationScopeExecution.IsActive = false; //compensationScopeExecution.activityInstanceStarting(); //compensationScopeExecution.enterActivityInstance(); //EventSubscriptionEntity eventSubscription = EventSubscriptionEntity.createAndInsert(parentExecution, // EventType.COMPENSATE, (ActivityImpl) scope); //eventSubscription.Configuration = compensationScopeExecution.Id; //executionBranch.visited(new MigratingEventScopeInstance(eventSubscription, compensationScopeExecution, // scope)); parentExecution = compensationScopeExecution; } }
/// <summary> /// Returns a list of flow scopes from the given scope until a scope is reached that is already present in the given /// <seealso cref="MigratingScopeInstanceBranch" /> (exclusive). The order of the returned list is top-down, i.e. the /// highest scope /// is the first element of the list. /// </summary> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: protected java.Util.List<org.camunda.bpm.engine.impl.Pvm.Process.ScopeImpl> collectNonExistingFlowScopes(org.camunda.bpm.engine.impl.Pvm.Process.ScopeImpl scope, final MigratingScopeInstanceBranch migratingExecutionBranch) protected internal virtual IList <ScopeImpl> CollectNonExistingFlowScopes(ScopeImpl scope, MigratingScopeInstanceBranch migratingExecutionBranch) { var walker = new FlowScopeWalker(scope); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.Util.List<org.camunda.bpm.engine.impl.Pvm.Process.ScopeImpl> result = new java.Util.LinkedList<org.camunda.bpm.engine.impl.Pvm.Process.ScopeImpl>(); IList <ScopeImpl> result = new List <ScopeImpl>(); walker.AddPreVisitor(new TreeVisitorAnonymousInnerClass(this, result)); //walker.walkWhile(new WalkConditionAnonymousInnerClass(this, migratingExecutionBranch)); return(result); }
protected internal virtual void MigrateProcessElementInstance(MigratingProcessElementInstance migratingInstance, MigratingScopeInstanceBranch migratingInstanceBranch) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final MigratingScopeInstance parentMigratingInstance = migratingInstance.Parent; var parentMigratingInstance = migratingInstance.Parent; var sourceScope = migratingInstance.SourceScope; var targetScope = migratingInstance.TargetScope; var targetFlowScope = targetScope.FlowScope; var parentActivityInstanceTargetScope = parentMigratingInstance != null ? parentMigratingInstance.TargetScope : null; if ((sourceScope != sourceScope.ProcessDefinition) && (targetFlowScope != parentActivityInstanceTargetScope)) { // create intermediate scopes // 1. manipulate execution tree // determine the list of ancestor scopes (parent, grandparent, etc.) for which // no executions exist yet var nonExistingScopes = CollectNonExistingFlowScopes(targetFlowScope, migratingInstanceBranch); // get the closest ancestor scope that is instantiated already var existingScope = nonExistingScopes.Count == 0 ? targetFlowScope : nonExistingScopes[0].FlowScope; // and its scope instance var ancestorScopeInstance = migratingInstanceBranch.GetInstance(existingScope); // Instantiate the scopes as children of the scope execution InstantiateScopes(ancestorScopeInstance, migratingInstanceBranch, nonExistingScopes); var targetFlowScopeInstance = migratingInstanceBranch.GetInstance(targetFlowScope); // 2. detach instance // The order of steps 1 and 2 avoids intermediate execution tree compaction // which in turn could overwrite some dependent instances (e.g. variables) migratingInstance.DetachState(); // 3. attach to newly created activity instance migratingInstance.AttachState(targetFlowScopeInstance); } // 4. update state (e.g. activity id) migratingInstance.MigrateState(); // 5. migrate instance state other than execution-tree structure migratingInstance.MigrateDependentEntities(); }
protected internal override ICollection <MigrationContext> NextElements() { ICollection <MigrationContext> nextElements = new LinkedList <MigrationContext>(); var currentElement = CurrentElement; // continue migration for non-leaf instances (i.e. scopes) if (currentElement.processElementInstance is MigratingScopeInstance) { // Child instances share the same scope instance branch; // This ensures "once-per-parent" instantiation semantics, // i.e. if a new parent scope is added to more than one child, all those children // will share the same new parent instance. // By changing the way how the branches are created here, it should be possible // to implement other strategies, e.g. "once-per-child" semantics var childrenScopeBranch = currentElement.scopeInstanceBranch.Copy(); var childrenCompensationScopeBranch = currentElement.scopeInstanceBranch.Copy(); var scopeInstance = (MigratingScopeInstance)currentElement.processElementInstance; childrenScopeBranch.Visited(scopeInstance); childrenCompensationScopeBranch.Visited(scopeInstance); foreach (var child in scopeInstance.Children) { MigratingScopeInstanceBranch instanceBranch = null; // compensation and non-compensation scopes cannot share the same scope instance branch // e.g. when adding a sub process, we want to create a new activity instance as well // as a new event scope instance for that sub process if (child is MigratingEventScopeInstance || child is MigratingCompensationEventSubscriptionInstance) { instanceBranch = childrenCompensationScopeBranch; } else { instanceBranch = childrenScopeBranch; } nextElements.Add(new MigrationContext(child, instanceBranch)); } } return(nextElements); }
protected internal override void InstantiateScopes(MigratingScopeInstance ancestorScopeInstance, MigratingScopeInstanceBranch executionBranch, IList <ScopeImpl> scopesToInstantiate) { if (scopesToInstantiate.Count == 0) { return; } // must always be an activity instance var ancestorActivityInstance = (MigratingActivityInstance)ancestorScopeInstance; var newParentExecution = ancestorActivityInstance.CreateAttachableExecution(); //IDictionary<IPvmActivity, PvmExecutionImpl> createdExecutions = // newParentExecution.instantiateScopes((IList) scopesToInstantiate, skipCustomListeners, skipIoMappings); //foreach (var scope in scopesToInstantiate) //{ // var createdExecution = (ExecutionEntity) createdExecutions[scope]; // createdExecution.setActivity(null); // createdExecution.Active = false; // executionBranch.visited(new MigratingActivityInstance(scope, createdExecution)); //} }
public MigrationContext(MigratingProcessElementInstance processElementInstance, MigratingScopeInstanceBranch scopeInstanceBranch) { this.processElementInstance = processElementInstance; this.scopeInstanceBranch = scopeInstanceBranch; }
protected internal abstract void InstantiateScopes(MigratingScopeInstance ancestorScopeInstance, MigratingScopeInstanceBranch executionBranch, IList <ScopeImpl> scopesToInstantiate);