| Pré. | Proc. |
Code Java généré à partir d' Statemachine héritée Gabarit
énumération privée StateType : int
{
ProcessusCommande_Livrée,
ProcessusCommande_Emballée,
ProcessusCommande_Fermée,
ProcessusOrder_Dispatched,
ProcessOrder_New,
ST_NOSTATE
}
énumération privée TransitionType : int
{
ProcessOrder_Delivered_to_ProcessOrder_Closed,
TT_NOTRANSITION
}
énumération privée CommandType
{
Faire,
Entrée,
Sortie
}
État privéType currState;
État privéType nextState;
TransitionType privé currTransition;
transcendance booléenne privée ;
État privé Type ProcessOrder_history ;
processus privé voidOrder_Delivered(CommandType commande)
{
commutateur(commande)
{
affaire à faire :
{
// Faire des comportements..
setStatus(Livré);
// Les transitions State
si((statut==Livré))
{
nextState = StateType.ProcessOrder_Closed;
currTransition = TransitionType.ProcessOrder_Delivered_to_ProcessOrder_Closed;
}
casser;
}
défaut:
{
casser;
}
}
}
processus privé voidOrder_Packed(CommandType commande)
{
commutateur(commande)
{
affaire à faire :
{
// Faire des comportements..
setStatus(Emballé);
// Les transitions State
nextState = StateType.ProcessOrder_Dispatched;
casser;
}
défaut:
{
casser;
}
}
}
processus privé voidOrder_Closed(CommandType commande)
{
commutateur(commande)
{
affaire à faire :
{
// Faire des comportements..
// Les transitions State
casser;
}
défaut:
{
casser;
}
}
}
processus privé voidOrder_Dispatched(CommandType commande)
{
commutateur(commande)
{
affaire à faire :
{
// Faire des comportements..
setStatus(Expédié);
// Les transitions State
nextState = StateType.ProcessOrder_Delivered;
casser;
}
défaut:
{
casser;
}
}
}
processus privé voidOrder_New(CommandType commande)
{
commutateur(commande)
{
affaire à faire :
{
// Faire des comportements..
setStatus(nouveau);
// Les transitions State
nextState = StateType.ProcessOrder_Packed;
casser;
}
défaut:
{
casser;
}
}
}
privé void StatesProc(StateType currState, CommandType commande)
{
commutateur(état actuel)
{
cas ProcessOrder_Delivered :
{
processOrder_Delivered(commande);
casser;
}
cas ProcessOrder_Packed :
{
processOrder_Packed(commande);
casser;
}
dossier ProcessOrder_Closed :
{
processOrder_Closed(commande);
casser;
}
cas ProcessOrder_Dispatched :
{
processOrder_Dispatched(commande);
casser;
}
affaire ProcessOrder_New :
{
processOrder_New(commande);
casser;
}
défaut:
casser;
}
}
privé void TransitionsProc(TransitionType transition)
{
commutateur (transition)
{
dossier ProcessOrder_Delivered_to_ProcessOrder_Closed :
{
setStatus(fermé);
casser;
}
défaut:
casser;
}
}
privé void initalizeStateMachine()
{
currState = StateType.ProcessOrder_New;
État suivant = Type d'État.ST_NOSTATE;
currTransition = TransitionType.TT_NOTRANSITION;
}
privé void runStateMachine()
{
tandis que (vrai)
{
si (currState == StateType.ST_NOSTATE)
{
casser;
}
currTransition = TransitionType.TT_NOTRANSITION;
ÉtatsProc(currState, CommandType.Do);
// puis vérifiez s'il existe une transition valide attribuée après le comportement do
si (nextState == StateType.ST_NOSTATE)
{
casser;
}
si (currTransition != TransitionType.TT_NOTRANSITION)
{
TransitionsProc(currTransition);
}
si (état actuel != état suivant)
{
ÉtatsProc(currState, CommandType.Exit);
StatesProc(nextState, CommandType.Entry);
currState = État suivant;
}
}
}