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 ;

}

}

}