Please note : This help page is not for the latest version of Enterprise Architect. The latest help can be found here.

Java Code Generated From State Machine Diagram

 

stm ProcessOrder

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 ;

                 }

         }

 }