protected internal override void exit(NSFStateMachineContext context)
        {
            // Additional behavior
            if (!active)
            {
                return;
            }

            // Set all associated regions' active substates to null state
            foreach (NSFTransition incomingTransition in incomingTransitions)
            {
                // Simple case of transition source is a state
                if (incomingTransition.Source.ParentRegion != null)
                {
                    incomingTransition.Source.ParentRegion.setActiveSubstate(NSFState.NullState);
                }
                else // A region can also be specified as part of a fork-join to fork-join transition
                {
                    NSFForkJoinTransition forkJoinTransition = incomingTransition as NSFForkJoinTransition;
                    if ((forkJoinTransition != null) && (forkJoinTransition.ForkJoinRegion != null))
                    {
                        forkJoinTransition.ForkJoinRegion.setActiveSubstate(NSFState.NullState);
                    }
                }
            }

            // Remove all completed transitions
            completedTransitions.Clear();

            // Base class behavior
            base.exit(context);
        }
        protected internal override void enter(NSFStateMachineContext context, bool useHistory)
        {
            // Additional behavior

            // Enter parent state, if necessary
            if (!parentState.isActive())
            {
                parentState.enter(context, false);
            }

            // Add transition to list of completed transitions
            completedTransitions.Add(context.Transition);

            // Set associated region's active substate to this

            // Simple case of transition source is a state
            if (context.Transition.Source.ParentRegion != null)
            {
                context.Transition.Source.ParentRegion.setActiveSubstate(this);
            }
            else // A region can also be specified as part of a fork-join to fork-join transition
            {
                NSFForkJoinTransition forkJoinTransition = context.Transition as NSFForkJoinTransition;
                if ((forkJoinTransition != null) && (forkJoinTransition.ForkJoinRegion != null))
                {
                    forkJoinTransition.ForkJoinRegion.setActiveSubstate(this);
                }
            }

            base.enter(context, useHistory);
        }
        protected internal override void enter(NSFStateMachineContext context, bool useHistory)
        {
            // Additional behavior

            // Enter parent state, if necessary
            if (!parentState.isActive())
            {
                parentState.enter(context, false);
            }

            // Add transition to list of completed transitions
            completedTransitions.Add(context.Transition);

            // Set associated region's active substate to this

            // Simple case of transition source is a state
            if (context.Transition.Source.ParentRegion != null)
            {
                context.Transition.Source.ParentRegion.setActiveSubstate(this);
            }
            else // A region can also be specified as part of a fork-join to fork-join transition
            {
                NSFForkJoinTransition forkJoinTransition = context.Transition as NSFForkJoinTransition;
                if ((forkJoinTransition != null) && (forkJoinTransition.ForkJoinRegion != null))
                {
                    forkJoinTransition.ForkJoinRegion.setActiveSubstate(this);
                }
            }

            base.enter(context, useHistory);
        }
        /// <summary>
        /// Enters the state.
        /// </summary>
        /// <param name="context">The event arguments pertaining to the transition into the state.</param>
        /// <param name="useHistory">Used by history states to reconstitute state history.</param>
        /// <remarks>
        /// This method is for use only by the North State Framework's internal logic.
        /// </remarks>
        protected internal virtual void enter(NSFStateMachineContext context, bool useHistory)
        {
            active = true;

            if (parentRegion != null)
            {
                parentRegion.setActiveSubstate(this);

                if (!parentRegion.isActive())
                {
                    parentRegion.enter(context, false);
                }
            }

            if (TopStateMachine.LoggingEnabled && LogEntry)
            {
                NSFTraceLog.PrimaryTraceLog.addTrace(NSFTraceTags.StateEnteredTag,
                                                     NSFTraceTags.StateMachineTag, TopStateMachine.Name,
                                                     NSFTraceTags.StateTag, Name);
            }

            // Update context to indicate entering this state
            context.EnteringState = this;
            context.ExitingState  = null;

            EntryActions.execute(context);

            NSFStateMachine parentStateMachine = ParentStateMachine;

            if (parentStateMachine != null)
            {
                parentStateMachine.executeStateChangeActions(context);
            }
        }
        protected internal override void exit(NSFStateMachineContext context)
        {
            // Additional behavior
            exitRegions(context);

            // Base class behavior
            base.exit(context);
        }
        protected internal override void enter(NSFStateMachineContext context, bool useHistory)
        {
            // Base class behavior
            base.enter(context, useHistory);

            // Additional behavior
            enterRegions(context, useHistory);
        }
Esempio n. 7
0
        /// <summary>
        /// Exits the region.
        /// </summary>
        /// <param name="context">Additional contextual information.</param>
        internal void exit(NSFStateMachineContext context)
        {
            active = false;

            if (activeSubstate != NSFState.NullState)
            {
                activeSubstate.exit(context);
            }
        }
        private void retrySend(NSFStateMachineContext context)
        {
            NSFDebugUtility.PrimaryDebugUtility.writeLineToConsole("Retry send ...");
            ++retries;
            // Code to re-send the command goes here
            // ...

            // Schedule timeout event, in case no response received           
            responseTimeoutEvent.schedule(responseTimeout, 0);
        }
 /// <summary>
 /// Exits all the regions of the composite state.
 /// </summary>
 internal void exitRegions(NSFStateMachineContext context)
 {
     foreach (NSFRegion region in regions)
     {
         if (region.isActive())
         {
             region.exit(context);
         }
     }
 }
 /// <summary>
 /// Enters all the regions of the composite state.
 /// </summary>
 /// <param name="context">Additional contextual information.</param>
 /// <param name="useHistory">Flag indicating if regions should be entered using the history substate.</param>
 internal void enterRegions(NSFStateMachineContext context, bool useHistory)
 {
     foreach (NSFRegion region in regions)
     {
         if (!region.isActive())
         {
             region.enter(context, useHistory);
         }
     }
 }
Esempio n. 11
0
        /// <summary>
        /// Executes the actions in the state change actions list.
        /// </summary>
        internal void executeStateChangeActions(NSFStateMachineContext context)
        {
            StateChangeActions.execute(context);

            NSFStateMachine parentStateMachine = ParentStateMachine;

            if (parentStateMachine != null)
            {
                parentStateMachine.executeStateChangeActions(context);
            }
        }
        protected internal override void enter(NSFStateMachineContext context, bool useHistory)
        {
            // Base class behavior
            base.enter(context, false);

            // Additional behavior

            // Enter history substate, not using recursive history
            NSFState historySubstate = parentRegion.HistorySubstate;
            if (historySubstate != NSFState.NullState)
            {
                historySubstate.enter(context, false);
            }
        }
Esempio n. 13
0
        protected internal override void enter(NSFStateMachineContext context, bool useHistory)
        {
            // Base class behavior
            base.enter(context, false);

            // Additional behavior

            // Enter history substate, using recursive history
            NSFState historySubstate = parentRegion.HistorySubstate;

            if (historySubstate != NSFState.NullState)
            {
                historySubstate.enter(context, true);
            }
        }
        /// <summary>
        /// Exits the state.
        /// </summary>
        /// <param name="context">The event arguments pertaining to the transition out of the state.</param>
        /// <remarks>
        /// This method is for use only by the North State Framework's internal logic.
        /// </remarks>
        protected internal virtual void exit(NSFStateMachineContext context)
        {
            active = false;

            // Update context to indicate exiting this state
            context.ExitingState  = this;
            context.EnteringState = null;

            ExitActions.execute(context);

            if (parentRegion != null)
            {
                parentRegion.setActiveSubstate(NSFState.NullState);
            }
        }
        protected override void fireTransition(NSFStateMachineContext context)
        {
            compositeSource.exitRegions(context);

            // Reset context possibly changed by exiting states
            context.EnteringState = null;
            context.ExitingState  = null;

            Actions.execute(context);

            if (Source != Target)
            {
                Target.enter(context, false);
            }
            else
            {
                compositeSource.enterRegions(context, false);
            }
        }
        protected override void fireTransition(NSFStateMachineContext context)
        {
            Source.exit(context);

            // Exit parent states until common parent is found
            NSFState parentState = Source.ParentState;
            while ((parentState != null) && (!parentState.isParent(Target)))
            {
                parentState.exit(context);
                parentState = parentState.ParentState;
            }

            // Reset context possibly changed by exiting states
            context.EnteringState = null;
            context.ExitingState = null;

            Actions.execute(context);

            Target.enter(context, false);
        }
Esempio n. 17
0
        protected override void fireTransition(NSFStateMachineContext context)
        {
            Source.exit(context);

            // Exit parent states until common parent is found
            NSFState parentState = Source.ParentState;

            while ((parentState != null) && (!parentState.isParent(Target)))
            {
                parentState.exit(context);
                parentState = parentState.ParentState;
            }

            // Reset context possibly changed by exiting states
            context.EnteringState = null;
            context.ExitingState  = null;

            Actions.execute(context);

            Target.enter(context, false);
        }
Esempio n. 18
0
        /// <summary>
        /// Enters the region.
        /// </summary>
        /// <param name="context">Additional contextual information.</param>
        /// <param name="useHistory">Flag indicating whether or not to use the history state as entry point.</param>
        internal void enter(NSFStateMachineContext context, bool useHistory)
        {
            active = true;

            if (!parentState.isActive())
            {
                parentState.enter(context, false);
            }

            if (useHistory)
            {
                if (historySubstate != NSFState.NullState)
                {
                    historySubstate.enter(context, useHistory);
                }
            }

            if (activeSubstate == NSFState.NullState)
            {
                initialState.enter(context, false);
            }
        }
Esempio n. 19
0
        /// <summary>
        /// Processes an event, evaluating if the event results in the transition firing.
        /// </summary>
        /// <remarks>
        /// This method is for use only by the North State Framework's internal logic.
        /// </remarks>
        protected internal NSFEventStatus processEvent(NSFEvent nsfEvent)
        {
            bool transitionTriggered = false;

            if (triggers.Count == 0)
            {
                transitionTriggered = true;
            }
            else
            {
                foreach (NSFEvent trigger in Triggers)
                {
                    if (trigger.Id == nsfEvent.Id)
                    {
                        transitionTriggered = true;
                        break;
                    }
                }
            }

            if (!transitionTriggered)
            {
                return(NSFEventStatus.NSFEventUnhandled);
            }

            NSFStateMachineContext newContext = new NSFStateMachineContext(Source.TopStateMachine, null, null, this, nsfEvent);

            if (!Guards.execute(newContext))
            {
                return(NSFEventStatus.NSFEventUnhandled);
            }

            fireTransition(newContext);

            return(NSFEventStatus.NSFEventHandled);
        }
 private void errorEntryActions(NSFStateMachineContext context)
 {
     // Code to handle the error goes here
     // ...
 }
 void terminateTest(NSFStateMachineContext context)
 {
     readyToTerminate = true;
 }
        /// <summary>
        /// Exits the region.
        /// </summary>
        /// <param name="context">Additional contextual information.</param>
        internal void exit(NSFStateMachineContext context)
        {
            active = false;

            if (activeSubstate != NSFState.NullState)
            {
                activeSubstate.exit(context);
            }
        }
        /// <summary>
        /// Enters the region.
        /// </summary>
        /// <param name="context">Additional contextual information.</param>
        /// <param name="useHistory">Flag indicating whether or not to use the history state as entry point.</param>
        internal void enter(NSFStateMachineContext context, bool useHistory)
        {
            active = true;

            if (!parentState.isActive())
            {
                parentState.enter(context, false);
            }

            if (useHistory)
            {
                if (historySubstate != NSFState.NullState)
                {
                    historySubstate.enter(context, useHistory);
                }
            }

            if (activeSubstate == NSFState.NullState)
            {
                initialState.enter(context, false);
            }
        }
Esempio n. 24
0
 /// <summary>
 /// Fires the transition.
 /// </summary>
 /// <param name="context">The state machine context associated with the transition firing.</param>
 /// <remarks>
 /// This method is for use only by the North State Framework's internal logic.
 /// </remarks>
 protected abstract void fireTransition(NSFStateMachineContext context);
        private bool isReady(NSFStateMachineContext context)
        {
            // Code to check if hardware is reset properly goes here
            // ...

            return true;
        }
        private void sendCommand(NSFStateMachineContext context)
        {
            String commandString = commandQueue.Peek();

            // Code to send the command goes here
            // ...

            // Log trace of command sent
            // Trace Format:
            // <MessageSent>
            //   <Source>name</Source>
            //   <Message>message</Message>
            // </MessageSent>
            NSFTraceLog.PrimaryTraceLog.addTrace(NSFTraceTags.MessageSentTag, NSFTraceTags.SourceTag, Name, NSFTraceTags.MessageTag, commandString);
        }
 private void queueCommand(NSFStateMachineContext context)
 {
     // Add data to command queue.
     // If the state machine is in the waitForCommandState, then the
     // run to completion step will result in transitioning to the
     // waitForResponse state, sending the command during the transtion.
     commandQueue.Enqueue(((NSFDataEvent<String>)(context.Trigger)).Data);
 }
 private void handleTransition(NSFStateMachineContext context)
 {
     NSFDebugUtility.PrimaryDebugUtility.writeLineToConsole("Transitioning from " + context.Transition.Source.Name
         + " to " + context.Transition.Target.Name);
 }
Esempio n. 29
0
 /// <summary>
 /// Queues the event to its destination.
 /// </summary>
 /// <remarks>
 /// This method is provided to allow event queuing to be registered as an entry, exit, or transition action.
 /// The event source will be changed to the context source for logging purposes during execution of this method.
 /// This method is not thread safe from a logging perspective, so that two threads calling this method on the same
 /// event can result in indeterminate logging of the source.
 /// </remarks>
 public void queueEvent(NSFStateMachineContext context)
 {
     Destination.queueEvent(this, context.Source);
 }
Esempio n. 30
0
 /// <summary>
 ///  Provides a syntactical method for specifying "Never" as a transition guard, effectively blocking the transition from ever occuring.
 /// </summary>
 public bool Never(NSFStateMachineContext context)
 {
     return(false);
 }
        protected override void fireTransition(NSFStateMachineContext context)
        {
            compositeSource.exitRegions(context);

            // Reset context possibly changed by exiting states
            context.EnteringState = null;
            context.ExitingState = null;

            Actions.execute(context);

            if (Source != Target)
            {
                Target.enter(context, false);
            }
            else
            {
                compositeSource.enterRegions(context, false);
            }
        }
 /// <summary>
 /// Queues the event to its destination.
 /// </summary>
 /// <remarks>
 /// This method is provided to allow event queuing to be registered as an entry, exit, or transition action.
 /// The event source will be changed to the context source for logging purposes during execution of this method.
 /// This method is not thread safe from a logging perspective, so that two threads calling this method on the same
 /// event can result in indeterminate logging of the source.
 /// </remarks>
 public void queueEvent(NSFStateMachineContext context)
 {
     Destination.queueEvent(this, context.Source);
 }
        private void handleResponse(NSFStateMachineContext context)
        {
            // Code to handle the response goes here
            // ...

            // Log trace of response received
            // Trace Format:
            // <MessageReceived>
            //   <Source>name</Source>
            //   <Message>message</Message>
            // </MessageReceived>
            NSFTraceLog.PrimaryTraceLog.addTrace(NSFTraceTags.MessageReceivedTag, NSFTraceTags.SourceTag, Name, NSFTraceTags.MessageTag, ((NSFDataEvent<String>)(context.Trigger)).Data);
        }
 private bool hasCommand(NSFStateMachineContext context)
 {
     return (commandQueue.Count != 0);
 }
        private void waitForResponseExitActions(NSFStateMachineContext context)
        {
            // Unschedule the timeout event
            responseTimeoutEvent.unschedule();

            commandQueue.Dequeue();
        }
        private bool isResponse(NSFStateMachineContext context)
        {
            // Code to verify that the resposne is correct for the command goes here.
            // ...

            return true;
        }
 private void state3_1ExitActions(NSFStateMachineContext context)
 {
     queueEvent(event3);
 }
 private void resetEntryActions(NSFStateMachineContext context)
 {
     // Code to reset hardware goes here
     // ...
 }
        /// <summary>
        /// Executes the actions in the state change actions list.
        /// </summary>
        internal void executeStateChangeActions(NSFStateMachineContext context)
        {
            StateChangeActions.execute(context);

            NSFStateMachine parentStateMachine = ParentStateMachine;
            if (parentStateMachine != null)
            {
                parentStateMachine.executeStateChangeActions(context);
            }
        }
 private void waitForResponseEntryActions(NSFStateMachineContext context)
 {
     // Schedule timeout event, in case no response received
     responseTimeoutEvent.schedule(responseTimeout, 0);
 }
 private void addValue(NSFStateMachineContext context)
 {
     value += 10;
 }
 private void state3ReactionToEvent1Actions(NSFStateMachineContext context)
 {
     queueEvent(event2);
 }
 private bool isValueHigh(NSFStateMachineContext context)
 {
     return (value > 10);
 }
 private void waitForResponseEntryActions(NSFStateMachineContext context)
 {
     retries = 0;
 }
 private bool isValueLow(NSFStateMachineContext context)
 {
     return (value < 10);
 }
 private void handleStateExited(NSFStateMachineContext context)
 {
     NSFDebugUtility.PrimaryDebugUtility.writeLineToConsole("Exiting " + context.ExitingState.Name);
 }
 private bool canRetry(NSFStateMachineContext context)
 {
     return (retries < maxRetries);
 }
Esempio n. 48
0
 protected override void fireTransition(NSFStateMachineContext context)
 {
     Actions.execute(context);
 }
 /// <summary>
 ///  Provides a syntactical method for specifying "Never" as a transition guard, effectively blocking the transition from ever occuring.
 /// </summary>
 public bool Never(NSFStateMachineContext context)
 {
     return false;
 }