Finite State Machine with Sub-state

• Download FSM_Application - 8.3 KB
• Download FSM_Source - 19.85 KB 

Introduction

This is an idea of implementing Finite State Machine with sub-state. Suppose there is a State Model as above picture. Below is transition table:

Framework classes 

Two abstract classes StateMgmt and State will be used to implement any particular state model

StateMgmt:<o:p> 

This class handles the entire state model. It handles triggers and changes current state according to received trigger.
This class contains only one state (called Root state). Root state contains sub-states and StateMgmt will use Root state to handle triggers. 

State:<o:p> 

This class represents one particular state in model (can be container-state or smallest sub-state). It can contains many sub-state, and at one time it can have only one sub-state is activated.
If one state has sub-states, it can activate the route to any state which is its child (can be sub-state, or sub-state of sub-state…) by using method GoToState.

Example (see below picture):If state [C] is activated: the route from [Root] to [C] is: [Root] --> [A] --> [C]
 

By using method GoToState, state [Root] can activate its child state [F] directly, and the route will be: [Root]  --> [B] --> [F] 

Each state must have a pointer to StateMgmt instance, so it can change from current state to any state in model (by using method GoToState of class StateMgmt).

As default, when a state handles a trigger, if it has sub-states it will call method HandleTrigger of its direct activated sub-state. Therefore, which state handles actual triggers, it has to override method HandleTrigger. 

Implementation of class StateMgmt: 

public abstract class StateMgmt
{
    protected State rootState = null;

    public State GetCurrentState()
    {
        if (this.rootState != null)
        {
            return rootState.GetCurrentState();
        }
        return null;
    }

    public virtual void GoToState(int stateId)
    {
        if (rootState != null)
        {
            rootState.GoToState(stateId);
        }
        else
        {
            throw new Exception("Root state is not initialized");
        }
    }

    public virtual void HandleTrigger(int trigger)
    {
        if (this.rootState != null)
        {
            rootState.HandleTrigger(trigger);
        }
    }
}

Implementation of class State: 

public abstract class State
{
    private int stateId = -1;

    protected State currentSubState = null;

    protected StateMgmt mgmt = null;

    protected ArrayList subStates = new ArrayList();

    public int StateId
    {
        get
        {
            return this.stateId;
        }
        set
        {
            this.stateId = value;
        }
    }

    public State(int stateId, StateMgmt mgmt)
    {
        this.stateId = stateId;
        this.mgmt = mgmt;
    }

    public abstract void Activated();

    public abstract string GetStateName();

    public State GetCurrentState()
    {
        if (this.currentSubState == null)
        {
            return this;
        }
        return this.currentSubState.GetCurrentState();
    }

    public virtual void GoToState(int stateId)
    {
        foreach (State s in subStates)
        {
            if (s.StateId == stateId)
            {
                this.currentSubState = s;
                s.Activated();
                return;
            }
            else
            {
                try
                {
                    s.GoToState(stateId);
                    this.currentSubState = s;
                    return;
                }
                catch
                {
                }
            }
        }
        throw new Exception("Invalid target state");
    }

    public virtual void HandleTrigger(int trigger)
    {
        if (this.currentSubState != null)
        {
            this.currentSubState.HandleTrigger(trigger);
        }
    }

    public void AddSubState(State newState)
    {
        this.subStates.Add(newState);
    }
}

Implementing an entire State model

Create classes inherit from two Framework classes: 

In class DemoStateMgmt:
- Define some necessary constants (State Id and Trigger Id)
- Build up the structure of model by adding sub-states to root state of DemoStateMgmt

public class DemoStateMgmt : StateMgmt
{
    public const int State_NoState = 1;
    public const int State_Init = 2;
    public const int State_InitA = 3;
    public const int State_InitB = 4;
    public const int State_Executing = 5;
    public const int State_Loaded = 6;
    public const int State_LoadedA = 7;
    public const int State_LoadedB = 8;
    public const int State_Processing = 9;
    public const int State_Paused = 10;

    public const int Trigger_Start = 1;
    public const int Trigger_LoadA = 2;
    public const int Trigger_LoadB = 3;
    public const int Trigger_Run = 4;
    public const int Trigger_Pause = 5;
    public const int Trigger_Resume = 6;
    public const int Trigger_Stop = 7;

    public DemoStateMgmt()
    {
        //Create state Root
        this.rootState = new RootState(-1, this);

        //Create state Init and its sub-states
        Init stateInit = new Init(State_Init, this);
        stateInit.AddSubState(new InitA(State_InitA, this));
        stateInit.AddSubState(new InitB(State_InitB, this));

        //Create state Loaded and its sub-states
        Loaded stateLoaded = new Loaded(State_Loaded, this);
        stateLoaded.AddSubState(new LoadedA(State_LoadedA, this));
        stateLoaded.AddSubState(new LoadedB(State_LoadedB, this));

        //Create state Executing and its sub-states
        Executing stateExecuting = new Executing(State_Executing, this);
        stateExecuting.AddSubState(stateLoaded);
        stateExecuting.AddSubState(new Processing(State_Processing, this));

        //Add sub-states to state Root
        this.rootState.AddSubState(new NoState(State_NoState, this));
        this.rootState.AddSubState(stateInit);
        this.rootState.AddSubState(stateExecuting);
        this.rootState.AddSubState(new Paused(State_Paused, this));

        //Go to first state
        this.rootState.GoToState(State_NoState);
    }
}

Normally, each smallest sub-state will override method HandleTrigger. But in some cases when the model leaves out from a state which has sub-states, only this state needs to override method HandleTrigger.

Similar idea, when the model goes to a state which has sub-states, it only needs to go to this state. It is not necessary to indicate exactly which sub-sate it will go to. But in this case, it is very important to override method Activated of this state. This method will activate (go to) exactly its sub-state as desired.

Example with class Init: 

public class Init : State
{
    public Init(int stateId, StateMgmt mgmt)
        : base(stateId, mgmt)
    {
    }

    public override void Activated()
    {
        switch (Configuration.DefaultInit)
        {
            case Configuration.InitA:
                GoToState(DemoStateMgmt.State_InitA);
                return;
            case Configuration.InitB:
                GoToState(DemoStateMgmt.State_InitB);
                return;
        }
    }

    public override string GetStateName()
    {
        return "Init";
    }
}

Example with class Executing: 

public class Executing : State
{
    public Executing(int stateId, StateMgmt mgmt)
        : base(stateId, mgmt)
    {
    }

    public override void Activated()
    {
        this.currentSubState.Activated();
    }

    public override string GetStateName()
    {
        return "Executing";
    }

    public override void HandleTrigger(int trigger)
    {
        switch (trigger)
        {
            case DemoStateMgmt.Trigger_Pause:
                Pause();
                return;
            //case another:
            //case another:
        }
        base.HandleTrigger(trigger);
    }

    private void Pause()
    {
        this.mgmt.GoToState(DemoStateMgmt.State_Paused);
    }
}

Above is explanation about the pattern and there is only source code of some classes. You can download the entire project. If you are not clear about any, or if you have any idea for this pattern, please feel free to contact with me by email: caohuuloc@gmail.com

History 

2008-10-05: Version 1.0.