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 on y entre.

Dans tous les cas, le comportement d'entrée de l' State est exécuté (s'il est défini) à l'entrée, mais seulement après la fin de tout comportement d'effet associé à la transition entrante. De plus, si un comportement doActivity est défini pour l' State , ce comportement commence son exécution 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 :

Entrée 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 avoir forgé une éventuelle exécution de comportement doActivity, l'entrée State continue à partir d'un pseudo-état initial via sa transition sortante (appelée 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 dans 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 du comportement d'entrée 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 peu profonde : si la transition entrante se termine sur un pseudo-état d'historique peu profonde 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 état final, une transition d'historique peu profonde 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 active 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 à partir des points d'entrée, chaque transition doit cibler une région différente et toutes les régions sont activées simultanément

Pour States orthogonaux à plusieurs Régions, si la Transition entre explicitement dans une ou plusieurs Régions (dans le cas d'une Fourche ou d'un point d'entrée), ces Régions sont saisies 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

Example StateMachine transitions diagram in Sparx Systems Enterprise Architect

Contexte de Statemachine

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

Statemachine

Ajoutez au diagramme un nœud initial , un State nommé State1 , un State nommé State2 et un élément final nommé final.
Agrandissez l'État 2 sur le diagramme , cliquez-droit dessus et sélectionnez l'option « Avancé | Définir les sous-états simultanés », puis définissez la Région B, la Région C, la Région D et la Région E.
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 .
Dans la RégionB , créez les éléments InitialB , transition vers l'ÉtatB1 , transition vers l'ÉtatB2 , transition vers l'ÉtatB3 ; toutes les transitions déclenchées par l'événement B.
Dans RegionC , créez les éléments shallow HistoryC ( cliquez-droit sur le nœud History | Advanced | Deep History | décochez ), transition to StateC1 , transition to StateC2 , transition to StateC3 ; toutes les transitions déclenchées par Event C.
Dans RegionD , créer les éléments deep HistoryD ( cliquez-droit sur le noeud History | Advanced | Deep History | check ), transition vers StateD1 , créer StateD2 comme parent de StateD3 , qui est parent de StateD4 ; transition de StateD1 à StateD4 ; déclenchée par l'événement D.
Dans RegionE , créez les éléments InitialE , transition vers StateE1 , transition vers StateE2 , transition vers StateE3 ; toutes les transitions déclenchées par l'événement E.
Dessinez les transitions du point d’entrée EP1 vers l’État C1 et l’État D1.

Dessiner des transitions pour différents types d'entrées :

Entrée par défaut : État 1 à État 2 ; déclenché par l'événement DEFAULT.
Entrée explicite : État1 à ÉtatB2 ; déclenché par l'événement EXPLICIT.
Entrée d'historique superficiel : État 1 vers Historique C ; déclenchée par l'événement SHALLOW.
Entrée d'historique profond : État 1 à Historique D ; déclenché par l'événement DEEP.
Point d'entrée Entrée : État 1 à EP1 ; déclenché par l'événement ENTRYPOINT.

Autres transitions :

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

Simulation

Artefact

Enterprise Architect 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.)

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 .
Maintenez Ctrl+faites glisser l'élément MyClass de la fenêtre Navigateur sur l'artefact EnteringAStateSimulation , sélectionnez l'option « Coller comme propriété » et donnez à la propriété le nom myClass.

Executable StateMachine for SysML simulation in Sparx Systems Enterprise Architect

Génération de code

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

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

Generating code for an executable state machine

Exécuter Simulation

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

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