Pré. | Proc. |
Code Java généré à partir de l'ancienne machine à Statemachine Gabarit
Énumération privée StateType : int
{
ProcessOrder_Delivered,
ProcessOrder_Packed,
TraiterCommande_Fermée,
ProcessOrder_Dispatched,
TraiterCommande_Nouveau,
ST_NOSTATE
}
Énumération privée Type de transition : int
{
ProcessOrder_Delivered_to_ProcessOrder_Closed,
TT_NOTRANSITION
}
Énumération privée CommandType
{
Fais,
Entrée,
Sortir
}
type d'état privé état_actuel ;
état suivant privé StateType ;
privé TransitionType currTransition ;
transcendance booléenne privée ;
état privé ProcessOrder_history ;
private void processOrder_Delivered (commande CommandType)
{
commutateur (commande)
{
cas faire :
{
// Faire des comportements..
setStatus(Livré);
// Transitions de l' State
if((statut==Livré))
{
nextState = StateType.ProcessOrder_Closed ;
currTransition = TransitionType.ProcessOrder_Delivered_to_ProcessOrder_Closed ;
}
Pause;
}
défaut:
{
Pause;
}
}
}
private void processOrder_Packed (commande CommandType)
{
commutateur (commande)
{
cas faire :
{
// Faire des comportements..
setStatus(Packed);
// Transitions de l' State
nextState = StateType.ProcessOrder_Dispatched ;
Pause;
}
défaut:
{
Pause;
}
}
}
private void processOrder_Closed (commande CommandType)
{
commutateur (commande)
{
cas faire :
{
// Faire des comportements..
// Transitions de l' State
Pause;
}
défaut:
{
Pause;
}
}
}
private void processOrder_Dispatched (commande CommandType)
{
commutateur (commande)
{
cas faire :
{
// Faire des comportements..
setStatus(Envoyé);
// Transitions de l' State
nextState = StateType.ProcessOrder_Delivered ;
Pause;
}
défaut:
{
Pause;
}
}
}
private void processOrder_New (commande CommandType)
{
commutateur (commande)
{
cas faire :
{
// Faire des comportements..
setStatus(nouveau);
// Transitions de l' State
nextState = StateType.ProcessOrder_Packed ;
Pause;
}
défaut:
{
Pause;
}
}
}
private void StatesProc(StateType currState, commande CommandType)
{
commutateur (étatactuel)
{
cas ProcessOrder_Delivered :
{
processOrder_Delivered(commande);
Pause;
}
cas ProcessOrder_Packed :
{
processOrder_Packed(commande);
Pause;
}
cas ProcessOrder_Closed :
{
processOrder_Closed(commande);
Pause;
}
cas ProcessOrder_Dispatched :
{
processOrder_Dispatched(commande);
Pause;
}
cas ProcessOrder_New :
{
processOrder_New(commande);
Pause;
}
défaut:
Pause;
}
}
vide privé TransitionsProc (transition de type de transition)
{
interrupteur (transition)
{
cas ProcessOrder_Delivered_to_ProcessOrder_Closed :
{
setStatus(fermé);
Pause;
}
défaut:
Pause;
}
}
vide privé initalizeStateMachine()
{
currState = StateType.ProcessOrder_New ;
nextState = StateType.ST_NOSTATE ;
currTransition = TransitionType.TT_NOTRANSITION ;
}
vide privé runStateMachine()
{
tandis que (vrai)
{
si (étatactuel == StateType.ST_NOSTATE)
{
Pause;
}
currTransition = TransitionType.TT_NOTRANSITION ;
StatesProc(currState, CommandType.Do);
// puis vérifie s'il y a une transition valide assignée après le comportement do
si (nextState == StateType.ST_NOSTATE)
{
Pause;
}
si (transition en cours != Type de transition.TT_NOTRANSITION)
{
TransitionsProc(currTransition);
}
si (étatactuel != étatsuivant)
{
StatesProc(currState, CommandType.Exit);
StatesProc(nextState, CommandType.Entry);
étatactuel = étatsuivant ;
}
}
}