Exemple #1
0
        protected override void UpdateInstance(NativeActivityUpdateContext updateContext)
        {
            int oldNodeIndex = updateContext.GetValue(this.currentNode);

            foreach (FlowNode node in this.reachableNodes)
            {
                if (node.ChildActivity != null)
                {
                    object originalValue = updateContext.GetSavedOriginalValue(node.ChildActivity);
                    if (originalValue != null)
                    {
                        int originalIndex = (int)originalValue;
                        if (originalIndex == oldNodeIndex)
                        {
                            updateContext.SetValue(this.currentNode, node.Index);
                            break;
                        }
                    }
                }
            }
        }
Exemple #2
0
        private void RescheduleNewlyAddedTriggers(NativeActivityUpdateContext updateContext)
        {
            // NOTE: triggers are scheduled already, so the state has completed executing State.Entry
            Fx.Assert(this.internalTransitions.Count == this.triggerInternalTransitionMapping.Count, "Triggers mappings are correct.");
            List<Activity> newTriggers = new List<Activity>();

            foreach (InternalTransition transition in this.internalTransitions)
            {
                if (updateContext.IsNewlyAdded(transition.Trigger))
                {
                    newTriggers.Add(transition.Trigger);
                }

                // NOTE: all Triggers in triggerInternalTransitionMapping are either new or was previously scheduled
            }

            foreach (Activity newTrigger in newTriggers)
            {
                updateContext.ScheduleActivity(newTrigger, this.onTriggerComplete);
            }

            updateContext.SetValue<int>(this.currentRunningTriggers, updateContext.GetValue(this.currentRunningTriggers) + newTriggers.Count);
        }
Exemple #3
0
        /// <summary>
        /// Used for Dynamic Update: after the instance is updated, if the statemachine is already transitioning, the index of the to-be-scheduled state 
        /// would need to be updated.
        /// </summary>
        /// <param name="updateContext">Dynamic Update context</param>
        /// <param name="eventManager">Internal StateMachineEventManager</param>
        /// <returns>True, 1. if update is successful and the instanced is updated with the new indexes, and 2 all the trigger ID in the queue are updated;
        /// false otherwise and the update should fail.</returns>
        private bool UpdateEventManager(
            NativeActivityUpdateContext updateContext,
            StateMachineEventManager eventManager)
        {
            Fx.Assert(null != eventManager.CurrentBeingProcessedEvent, "The eventManager must have some info that needs to be updated during transition.");

            int updatedEventsInQueue = 0;
            int originalTriggerId = int.MinValue;
            int originalConditionIndex = int.MinValue;
            bool updateCurrentEventSucceed = null == eventManager.CurrentBeingProcessedEvent ? true : false;

            foreach (InternalTransition transition in this.internalTransitions)
            {
                object savedTriggerIndex = updateContext.GetSavedOriginalValue(transition.Trigger);
                if (savedTriggerIndex != null)
                {
                    Fx.Assert(!updateContext.IsNewlyAdded(transition.Trigger), "the trigger in transition already exist.");

                    if (null != eventManager.CurrentBeingProcessedEvent &&
                        eventManager.CurrentBeingProcessedEvent.TriggedId == (int)savedTriggerIndex)
                    {
                        // found a match of the running trigger update the current processed event
                        // Don't match the trigger ID, match only when the Condition is also matched.
                        if (eventManager.CurrentConditionIndex == -1)
                        {
                            if (transition.IsUnconditional)
                            {
                                // executing transition before persist is unconditional
                                originalTriggerId = eventManager.CurrentBeingProcessedEvent.TriggedId;
                                originalConditionIndex = 0;
                                eventManager.CurrentBeingProcessedEvent.TriggedId = transition.InternalTransitionIndex;

                                if (updateContext.GetValue(this.isExiting))
                                {
                                    Fx.Assert(eventManager.OnTransition, "The state is transitioning.");
                                    updateContext.SetValue(this.Result, GetTo(transition.InternalTransitionIndex));
                                }

                                updateCurrentEventSucceed = true;
                            }
                            else
                            {
                                updateContext.DisallowUpdate(SR.ChangeTransitionTypeDuringTransitioningBlockDU);
                                return false;
                            }
                        }
                        else if (eventManager.CurrentConditionIndex >= 0)
                        {
                            Fx.Assert(!transition.IsUnconditional, "Cannot update a running conditional transition with a unconditional one.");

                            if (!transition.IsUnconditional)
                            {
                                // executing transition before and after are conditional
                                for (int updatedIndex = 0; updatedIndex < transition.TransitionDataList.Count; updatedIndex++)
                                {
                                    Activity condition = transition.TransitionDataList[updatedIndex].Condition;
                                    Fx.Assert(null != condition, "Conditional transition must have Condition activity.");
                                    int? savedCondIndex = updateContext.GetSavedOriginalValue(condition) as int?;

                                    if (eventManager.CurrentConditionIndex == savedCondIndex)
                                    {
                                        originalTriggerId = eventManager.CurrentBeingProcessedEvent.TriggedId;
                                        originalConditionIndex = eventManager.CurrentConditionIndex;
                                        eventManager.CurrentBeingProcessedEvent.TriggedId = transition.InternalTransitionIndex;
                                        eventManager.CurrentConditionIndex = updatedIndex;

                                        if (updateContext.GetValue(this.isExiting))
                                        {
                                            Fx.Assert(eventManager.OnTransition, "The state is transitioning.");
                                            updateContext.SetValue(this.Result, this.GetTo(transition.InternalTransitionIndex, (int)updatedIndex));
                                        }

                                        updateCurrentEventSucceed = true;
                                        break;
                                    }
                                }
                            }
                        }
                    }

                    foreach (TriggerCompletedEvent completedEvent in eventManager.Queue)
                    {
                        if ((int)savedTriggerIndex == completedEvent.TriggedId)
                        {
                            completedEvent.TriggedId = transition.InternalTransitionIndex;
                            updatedEventsInQueue++;
                        }
                    }
                }
            }

            return eventManager.Queue.Count() == updatedEventsInQueue ? updateCurrentEventSucceed : false;
        }