public class NewClass {
private enumStateType{
ProcessOrder_Delivered,
ProcessOrder_Packed,
ProcessOrder_Closed,
ProcessOrder_Dispatched,
ProcessOrder_New,
ST_NOSTATE
}
private enumTransitionType{
ProcessOrder_Delivered_to_ProcessOrder_Closed,
TT_NOTRANSITION
}
private enum CommandType{
Do,
Entry,
Exit,
Packed,
Dispatched,
New,
Delivered,
closed
}
private StateTypecurrState;
private StateTypenextState;
private TransitionTypecurrTransition;
private booleantranscend;
private StateTypeProcessOrder_history;
private voidprocessOrder_Delivered(CommandType command) {
switch (command) {
case Do:{
// Do Behaviors..
setStatus(CommandType.Delivered);
// State's Transitions
if ((currState ==StateType.ProcessOrder_Delivered)) {
nextState = StateType.ProcessOrder_Closed;
currTransition =TransitionType.ProcessOrder_Delivered_to_ProcessOrder_Closed;
}
break;
}
default:{
break;
}
}
}
private voidprocessOrder_Packed(CommandType command) {
switch (command) {
case Do:{
// Do Behaviors..
setStatus(CommandType.Packed);
// State's Transitions
nextState =StateType.ProcessOrder_Dispatched;
break;
}
default:{
break;
}
}
}
private voidprocessOrder_Closed(CommandType command) {
switch (command) {
case Do:{
// Do Behaviors..
// State's Transitions
break;
}
default:{
break;
}
}
}
private voidprocessOrder_Dispatched(CommandType command) {
switch (command) {
case Do:{
// Do Behaviors..
setStatus(CommandType.Dispatched);
// State's Transitions
nextState =StateType.ProcessOrder_Delivered;
break;
}
default:{
break;
}
}
}
private voidprocessOrder_New(CommandType command) {
switch (command) {
caseDo:{
// Do Behaviors..
setStatus(CommandType.New);
// State's Transitions
nextState =StateType.ProcessOrder_Packed;
break;
}
default:{
break;
}
}
}
private voidStatesProc(StateType currState, CommandType command) {
switch (currState) {
caseProcessOrder_Delivered: {
processOrder_Delivered(command);
break;
}
caseProcessOrder_Packed: {
processOrder_Packed(command);
break;
}
caseProcessOrder_Closed: {
processOrder_Closed(command);
break;
}
caseProcessOrder_Dispatched: {
processOrder_Dispatched(command);
break;
}
caseProcessOrder_New: {
processOrder_New(command);
break;
}
default:
break;
}
}
private voidTransitionsProc(TransitionType transition) {
switch (transition) {
caseProcessOrder_Delivered_to_ProcessOrder_Closed: {
setStatus(CommandType.closed);
break;
}
default:
break;
}
}
private voidinitalizeStateMachine() {
currState = StateType.ProcessOrder_New;
nextState = StateType.ST_NOSTATE;
currTransition =TransitionType.TT_NOTRANSITION;
}
private voidrunStateMachine() {
while (true) {
if(currState == StateType.ST_NOSTATE) {
break;
}
currTransition = TransitionType.TT_NOTRANSITION;
StatesProc(currState, CommandType.Do);
// thencheck if there is any valid transition assigned after the dobehavior
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;
}
}
}
private voidsetStatus(CommandType set){
}
}
