Java Code Generated From Legacy State Machine Template

private enum StateType: int

{

ProcessOrder_Delivered,

ProcessOrder_Packed,

ProcessOrder_Closed,

ProcessOrder_Dispatched,

ProcessOrder_New,

ST_NOSTATE

}

private enum TransitionType: int

{

ProcessOrder_Delivered_to_ProcessOrder_Closed,

TT_NOTRANSITION

}

private enum CommandType

{

Do,

Entry,

Exit

}

private StateType currState;

private StateType nextState;

private TransitionType currTransition;

private boolean transcend;

private StateType ProcessOrder_history;

private void processOrder_Delivered(CommandType command)

{

switch(command)

{

case Do:

{

// Do Behaviors..

setStatus(Delivered);

// State's Transitions

if((status==Delivered))

{

nextState = StateType.ProcessOrder_Closed;

currTransition = TransitionType.ProcessOrder_Delivered_to_ProcessOrder_Closed;

}

break;

}

default:

{

break;

}

}

}

private void processOrder_Packed(CommandType command)

{

switch(command)

{

case Do:

{

// Do Behaviors..

setStatus(Packed);

// State's Transitions

nextState = StateType.ProcessOrder_Dispatched;

break;

}

default:

{

break;

}

}

}

private void processOrder_Closed(CommandType command)

{

switch(command)

{

case Do:

{

// Do Behaviors..

// State's Transitions

break;

}

default:

{

break;

}

}

}

private void processOrder_Dispatched(CommandType command)

{

switch(command)

{

case Do:

{

// Do Behaviors..

setStatus(Dispatched);

// State's Transitions

nextState = StateType.ProcessOrder_Delivered;

break;

}

default:

{

break;

}

}

}

private void processOrder_New(CommandType command)

{

switch(command)

{

case Do:

{

// Do Behaviors..

setStatus(new);

// State's Transitions

nextState = StateType.ProcessOrder_Packed;

break;

}

default:

{

break;

}

}

}

private void StatesProc(StateType currState, CommandType command)

{

switch(currState)

{

case ProcessOrder_Delivered:

{

processOrder_Delivered(command);

break;

}

case ProcessOrder_Packed:

{

processOrder_Packed(command);

break;

}

case ProcessOrder_Closed:

{

processOrder_Closed(command);

break;

}

case ProcessOrder_Dispatched:

{

processOrder_Dispatched(command);

break;

}

case ProcessOrder_New:

{

processOrder_New(command);

break;

}

default:

break;

}

}

private void TransitionsProc(TransitionType transition)

{

switch(transition)

{

case ProcessOrder_Delivered_to_ProcessOrder_Closed:

{

setStatus(closed);

break;

}

default:

break;

}

}

private void initalizeStateMachine()

{

currState = StateType.ProcessOrder_New;

nextState = StateType.ST_NOSTATE;

currTransition = TransitionType.TT_NOTRANSITION;

}

private void runStateMachine()

{

while (true)

{

if (currState == StateType.ST_NOSTATE)

{

break;

}

currTransition = TransitionType.TT_NOTRANSITION;

StatesProc(currState, CommandType.Do);

// then check if there is any valid transition assigned after the do behavior

if ( nextState == StateType.ST_NOSTATE)

{

break;

}

if ( currTransition != TransitionType.TT_NOTRANSITION )

{

TransitionsProc(currTransition);

}

if (currState != nextState)

{

StatesProc(currState, CommandType.Exit);

StatesProc(nextState, CommandType.Entry);

currState = nextState;

}

}

}