public class NewClass {
private enum
StateType{
ProcessOrder_Delivered,
ProcessOrder_Packed,
ProcessOrder_Closed,
ProcessOrder_Dispatched,
ProcessOrder_New,
ST_NOSTATE
}
private enum
TransitionType{
ProcessOrder_Delivered_to_ProcessOrder_Closed,
TT_NOTRANSITION
}
private enum CommandType
{
Do,
Entry,
Exit,
Packed,
Dispatched,
New,
Delivered,
closed
}
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(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 void
processOrder_Packed(CommandType command) {
switch (command) {
case Do:
{
// Do Behaviors..
setStatus(CommandType.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(CommandType.Dispatched);
// State's Transitions
nextState =
StateType.ProcessOrder_Delivered;
break;
}
default:
{
break;
}
}
}
private void
processOrder_New(CommandType command) {
switch (command) {
case
Do:{
// Do Behaviors..
setStatus(CommandType.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(CommandType.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;
}
}
}
private void
setStatus(CommandType set){
}
}
加载中…
(2016-02-28 23:31:01)