Exemple : Entrer d'un State

La sémantique de l'entrée dans un State dépend du type d' State et de la manière dont il est entré.

Dans tous les cas, le comportement d'entrée de l' State est exécuté (si défini) lors de l'entrée, mais seulement après que tout comportement d'effet associé à la transition entrante est terminé. De plus, si un comportement doActivity est défini pour le State , ce comportement commence à s'exécuter immédiatement après l'exécution du comportement d'entrée.

Pour un State composite avec une ou plusieurs régions définies, un certain nombre d'alternatives existent pour chaque région :

• Saisie par défaut : Cette situation se produit lorsque l' State composite propriétaire est la cible directe d'une transition ; après avoir exécuté le comportement d'entrée et forké une éventuelle exécution du comportement doActivity, l'entrée d' State continue à partir d'un pseudo-état initial via sa transition sortante (connue sous le nom de transition par défaut de l' State ) si elle est définie dans la région
  Si aucun pseudo-état initial n'est défini, cette région ne sera pas active
• Entrée explicite : si la transition entrante ou ses continuations se terminent sur un sous-état directement contenu de l' State composite propriétaire, alors ce sous-état devient actif et son comportement d'entrée est exécuté après l'exécution de l'entrée Comportement de l' State composite contenant
  Cette règle s'applique de manière récursive si la transition se termine sur un sous-état indirect (profondément imbriqué)
• Entrée d'historique superficielle : si la transition entrante se termine sur un pseudo-état d'historique superficiel de cette région, le sous-état actif devient le sous-état qui était le plus récemment actif (sauf l'état final) avant cette entrée, à moins qu'il ne s'agisse de la première entrée dans cet State ; s'il s'agit de la première entrée dans cet State ou si l'entrée précédente avait atteint un final, une transition d'historique superficiel par défaut sera prise si elle est définie, sinon l'entrée State par défaut est appliquée
• Entrée d'historique profond : la règle pour ce cas est la même que pour l'historique superficiel, sauf que le pseudo-état cible est de type deepHistory et que la règle est appliquée de manière récursive à tous les niveaux de la configuration State actif en dessous de celui-ci.
• Entrée au point d'entrée : si une transition entre dans l' State composite propriétaire via un pseudo-état entryPoint, alors la transition sortante provenant du point d'entrée et pénétrant dans l' State de cette région est prise ; s'il y a plus de transitions sortantes depuis les points d'entrée, chaque transition doit cibler une région différente et toutes les régions sont activées simultanément

Pour les States orthogonaux avec plusieurs régions, si la transition entre explicitement dans une ou plusieurs régions (dans le cas d'un fork ou d'un point d'entrée), ces régions sont entrées explicitement et les autres par défaut.

Dans cet exemple, nous démontrons un modèle avec tous ces comportements d'entrée pour un State orthogonal.

Modélisation d'une Statemachine

Contexte de Statemachine

1. Créez un élément Class nommé MyClass , qui sert de contexte à Statemachine .
2. Cliquez Cliquez-droit sur MyClass dans la fenêtre du Navigateur et sélectionnez l'option 'Ajouter | Statemachine '.

Statemachine

1. Ajoutez au diagramme un nœud initial , un State nommé State1 , un State nommé State2 et un élément final nommé final.
2. Agrandissez State2 sur le diagramme , cliquez-droit dessus et sélectionnez l'onglet 'Avancé | Définir l'option Concurrent Substates et définir RegionB, RegionC, RegionD et RegionE.
3. Cliquez Cliquez-droit sur State2 et sélectionnez l'option 'Nouvel élément enfant | Point d'Entrée' pour créer le Point d'Entrée EP1 .
4. Dans RegionB , créez les éléments InitialB , transition to StateB1 , transition to StateB2 , transition to StateB3 ; toutes les transitions déclenchées par l'événement B.
5. Dans RegionC , créez les éléments peu profonds HistoryC ( cliquez-droit sur le nœud History | Advanced | Deep History | uncheck), transition to StateC1 , transition to StateC2 , transition to StateC3 ; toutes les transitions déclenchées par l'événement C.
6. Dans RegionD , créez les éléments deep HistoryD ( cliquez-droit sur le nœud History | Advanced | Deep History | check ), passez à StateD1 , créez StateD2 comme parent de StateD3 , qui est parent de StateD4 ; passage de StateD1 à StateD4 ; déclenché par l'événement D.
7. Dans RegionE , créez les éléments InitialE , transition to StateE1 , transition to StateE2 , transition to StateE3 ; toutes les transitions déclenchées par l'événement E.
8. Dessinez des transitions du point d'entrée EP1 à StateC1 et StateD1.

Dessinez des transitions pour différents types d'entrée :

1. Entrée par défaut : State1 à State2 ; déclenché par l'événement DEFAULT.
2. Entrée explicite : State1 à StateB2 ; déclenché par l'événement EXPLICIT.
3. Entrée d'historique peu profonde : State1 à HistoryC ; déclenché par l'événement SHALLOW.
4. Entrée d'historique approfondie : State1 à HistoryD ; déclenché par l'événement DEEP.
5. Entrée du point d'entrée : État1 à EP1 ; déclenché par l'événement ENTRYPOINT.

Autres transitions :

1. Sortie d' State composite : de State2 à State1 ; déclenché par l'événement BACK.
2. State1 à Final , déclenché par l'événement QUIT.

Simulation

Artefact

Enterprise Architect en supporte C, C++, C# , Java et JavaScript . Nous utilisons JavaScript dans cet exemple car nous n'avons pas besoin d'installer de compilateur. (Pour les autres langages, Visual Studio ou JDK sont requis.)

1. Sur la page ' Simulation ' de la boîte à outils Diagramme , faites glisser l'icône Statemachine Exécutable sur un diagramme et créez un artefact nommé EnteringAStateSimulation . Définissez le langage sur JavaScript .
2. Ctrl + faites glisser l'élément MyClass de la fenêtre Navigateur vers l'artefact EnteringAStateSimulation , sélectionnez l'option "Coller en tant que propriété" et donnez à la propriété le nom myClass.

Génération de codes

1. Cliquez sur EnteringAStateSimulation et sélectionnez l'option de ruban 'Simulate > États Statemachine États Exécutables Générer , Build and Exécuter '.
2. Spécifiez un répertoire pour le code source généré.

Note : Le contenu de ce répertoire sera effacé avant génération ; assurez-vous de spécifier un répertoire utilisé uniquement à des fins de simulation Statemachine .

Exécuter Simulation

Conseils : Vous pouvez visualiser la séquence de trace d'exécution depuis la fenêtre Simulation , que vous ouvrez en sélectionnant l'option du ruban 'Simuler > Simulation Dynamique > Simulateur > Ouvrir la fenêtre de Simulation '

Lorsque la simulation commence, State1 est actif et la Statemachine attend des événements.

Ouvrez la fenêtre Simulation Événements (Triggers) à l'aide de l'option du ruban 'Simuler > Simulation Dynamique > Événements '.

1) Sélectionnez l'entrée par défaut : Séquence de déclenchement [DEFAULT].

• RegionB est activé car il définit InitialB ; la transition qui en sort sera exécutée, StateB1 est l'état actif
• RegionE est activé car il définit InitialE ; la transition qui en sort sera exécutée, StateE1 est l'état actif
• RegionC et RegionD sont inactives car aucun pseudo-état initial n'a été défini

Sélectionnez le déclencheur [BACK] pour réinitialiser.

2) Sélectionnez l'entrée explicite : Séquence de déclenchement [EXPLICIT].

• RegionB est activé car la transition cible le sommet contenu StateB2
• RegionE est activé car il définit InitialE ; la transition qui en sort sera exécutée, StateE1 est l'état actif
• RegionC et RegionD sont inactives car aucun pseudo-état initial n'a été défini

Sélectionnez le déclencheur [BACK] pour réinitialiser.

3) Sélectionnez la transition d'historique par défaut : Séquence de déclenchement [SHALLOW].

• RegionC est activée car la transition cible le sommet contenu HistoryC ; puisque cette région est entrée pour la première fois (et que le pseudo-état History n'a rien à 'se souvenir'), la transition sortant de HistoryC à StateC1 est exécutée
• RegionB est activé car il définit InitialB ; la transition qui en sort sera exécutée, StateB1 est l'état actif
• RegionE est activé car il définit InitialE ; la transition qui en sort sera exécutée, StateE1 est l'état actif
• RegionD est inactive car aucun pseudo-état initial n'a été défini

4) Préparez-vous à tester l'entrée d'historique peu profonde : Séquence de déclenchement [C, C].

• Nous supposons que le pseudo-état d'historique peu profond HistoryC peut se souvenir de StateC3

Sélectionnez le déclencheur [BACK] pour réinitialiser.

5) Sélectionnez l'entrée d'historique Shallow : Séquence de déclenchement [SHALLOW].

• Pour RegionC , StateC3 est activé directement

Sélectionnez le déclencheur [BACK] pour réinitialiser.

6) Sélectionnez l'Entrée du Point d'Entrée : Séquence de Déclenchement [POINT D'ENTREE].

• RegionC est activé car la transition depuis EP1 cible le StateC1 contenu
• RegionD est activé car la transition depuis EP1 cible le StateD1 contenu
• RegionB est activé car il définit InitialB ; la transition qui en sort sera exécutée, StateB1 est l'état actif
• RegionE est activé car il définit InitialE ; la transition qui en sort sera exécutée, StateE1 est l'état actif

7) Préparez-vous à tester Deep History : Trigger Séquence [D].

• Nous supposons que le pseudo-état d'historique profond HistoryD peut se souvenir de StateD2 , StateD3 et StateD4

Sélectionnez le déclencheur [BACK] pour réinitialiser.

8) Sélectionnez l'entrée d'historique approfondie : Séquence de déclenchement [DEEP].

• Pour RegionD , StateD2 , StateD3 et StateD4 sont saisis ; les traces sont :
  - maClasse[MaClasse].StateMachine_State1 EXIT

- myClass[MyClass].State1__TO__HistoryD_105793_61752 Effet

- myClass[MyClass].StateMachine_State2 ENTRÉE

- maClasse[MaClasse].StateMachine_State2 DO

- myClass[MyClass].InitialE_105787__TO__StateE1_61746 Effet

- maClasse[MaClasse].StateMachine_State2_StateE1 ENTRÉE

- maClasse[MaClasse].StateMachine_State2_StateE1 FAIRE

- myClass[MyClass].InitialB_105785__TO__StateB1_61753 Effet

- maClasse[MaClasse].StateMachine_State2_StateB1 ENTRÉE

- maClasse[MaClasse].StateMachine_State2_StateB1 FAIRE

- maClasse[MaClasse].StateMachine_State2_StateD2 ENTRÉE

- maClasse[MaClasse].StateMachine_State2_StateD2_StateD3 ENTRÉE

- maClasse[MaClasse].StateMachine_State2_StateD2_StateD3_StateD4 ENTRÉE