Modélisation Statemachines Exécutables

La plupart du travail requis pour modéliser un Statemachine Exécutable est modélisation standard basée sur UML des classes et des modèles State , bien qu'il existe quelques conventions qui doivent être respectées pour garantir une base de code bien formée. La seule construction nouvelle est l'utilisation d'un élément Artifact stéréotypé pour former la configuration d'une instance ou d'un scénario Statemachine Exécutable . L'Artifact est utilisé pour spécifier des détails tels que :

Le langage de code ( JavaScript , C# , Java, C++ y compris C)
Les classes et Statemachines impliquées dans le scénario
Les spécifications d'instance, y compris l'état d'exécution ; note que cela peut inclure plusieurs instances de la même Statemachine , par exemple lorsqu'une classe « Joueur » est utilisée deux fois dans une simulation de match de tennis

Outils et objets Modélisation de base pour Statemachines Exécutables

Ce sont les principaux éléments modélisation utilisés lors de la construction Statemachines Exécutables .

Type d'élément	Description
Classes et Diagrammes de classes	Les classes définissent les types object pertinents pour la ou Statemachine modélisées. Par exemple, dans un scénario de match de tennis simple, vous pouvez définir une classe pour chaque joueur, match, Hit et arbitre. Chacun aura sa ou ses propres Statemachine et sera représenté au moment de l'exécution par des instances object pour chaque entité impliquée. Consultez le Guide Modélisation UML pour plus d'informations sur les classes et diagrammes de classes.
Statemachines	Pour chaque classe que vous définissez et qui aura un comportement dynamique dans un scénario, vous définirez généralement une ou plusieurs Statemachines UML . Chaque Statemachine déterminera le comportement légal basé sur l'état approprié pour un aspect de la classe propriétaire. Par exemple, il est possible d'avoir une Statemachine qui représente l'état émotionnel d'un joueur, une autre qui suit sa forme physique et ses niveaux d'énergie actuels, et une autre qui représente son état de victoire ou de défaite. Toutes ces Statemachines seront initialisées et démarrées lorsque le scénario Statemachine commencera à s'exécuter.
Artefact Statemachine Exécutable	Cet artefact stéréotypé est l'élément central utilisé pour spécifier les participants, la configuration et les conditions de démarrage d'un Statemachine Exécutable . Du point de vue du scénario, il est utilisé pour déterminer quelles instances (de classes) sont impliquées, quels événements elles peuvent Déclencheur et s'envoyer les unes aux autres, et dans quelles conditions de démarrage elles fonctionnent. Du point de vue de la configuration, l'Artifact est utilisé pour établir le lien vers un script d'analyse qui déterminera le répertoire de sortie, le langage de code, le script de compilation et autres. Un clic droit sur l'Artifact vous permettra de générer, construire, compiler et visualiser l'exécution en temps réel de vos Statemachines .

Type d'élément

Description

Classes et Diagrammes de classes

Les classes définissent les types object pertinents pour la ou Statemachine modélisées. Par exemple, dans un scénario de match de tennis simple, vous pouvez définir une classe pour chaque joueur, match, Hit et arbitre. Chacun aura sa ou ses propres Statemachine et sera représenté au moment de l'exécution par des instances object pour chaque entité impliquée. Consultez le Guide Modélisation UML pour plus d'informations sur les classes et diagrammes de classes.

Statemachines

Pour chaque classe que vous définissez et qui aura un comportement dynamique dans un scénario, vous définirez généralement une ou plusieurs Statemachines UML . Chaque Statemachine déterminera le comportement légal basé sur l'état approprié pour un aspect de la classe propriétaire. Par exemple, il est possible d'avoir une Statemachine qui représente l'état émotionnel d'un joueur, une autre qui suit sa forme physique et ses niveaux d'énergie actuels, et une autre qui représente son état de victoire ou de défaite. Toutes ces Statemachines seront initialisées et démarrées lorsque le scénario Statemachine commencera à s'exécuter.

Artefact Statemachine Exécutable

Cet artefact stéréotypé est l'élément central utilisé pour spécifier les participants, la configuration et les conditions de démarrage d'un Statemachine Exécutable . Du point de vue du scénario, il est utilisé pour déterminer quelles instances (de classes) sont impliquées, quels événements elles peuvent Déclencheur et s'envoyer les unes aux autres, et dans quelles conditions de démarrage elles fonctionnent.

Du point de vue de la configuration, l'Artifact est utilisé pour établir le lien vers un script d'analyse qui déterminera le répertoire de sortie, le langage de code, le script de compilation et autres. Un clic droit sur l'Artifact vous permettra de générer, construire, compiler et visualiser l'exécution en temps réel de vos Statemachines .

Constructions Statemachine prises en charge

Ce tableau détaille les constructions Statemachine prises en charge et toutes les limitations ou contraintes générales pertinentes pour chaque type.

Construction	Description
Statemachines	Statemachine simple : la Statemachine a une région Statemachine orthogonale : la Statemachine contient plusieurs régions Sémantique d'activation de la région de niveau supérieur (appartenant à Statemachine ) : Activation par défaut : lorsque la Statemachine commence à s’exécuter. Point d'entrée Entrée : Transitions du point d'entrée vers les sommets des régions contenues. Note 1 : Dans chaque région de la Statemachine possédant le point d'entrée, il existe au plus une seule transition du point d'entrée à un sommet dans cette région Note 2 : cette Statemachine peut être référencée par un State de sous-machine - les références de point de connexion doivent être définies dans l' State de sous-machine comme sources/cibles de transitions ; la référence de point de connexion représente une utilisation d'un point d'entrée/sortie défini dans la Statemachine et référencé par l' State de sous-machine Statemachines multiples : L'ordre d'affichage dans la fenêtre Navigateur détermine l'ordre d'exécution. Lorsqu'un State de sous-machine est impliqué, il peut y avoir plusieurs Statemachines sous la classe Utilisez les flèches Monter ou Descendre dans la barre d'outils de la fenêtre Navigateur pour ajuster l'ordre des Statemachines ; celle du haut sera définie comme Statemachine principale Non pris en charge Statemachine de protocole Redéfinition Statemachine
States	State simple : n'a pas de sommets ou de transitions internes State composite : contient exactement une région State orthogonal : contient plusieurs régions State de sous-machine : fait référence à une Statemachine entière
Entrée State composite	Entrée par défaut Entrée explicite Entrée d'histoire superficielle Entrée d'histoire profonde Point d'entrée Entrée
Sous-États	Sous-états et sous-états imbriqués La sémantique d'entrée et de sortie, où la transition comprend plusieurs niveaux d'états imbriqués, obéira à l'exécution correcte des comportements imbriqués (tels que OnEntry et OnExit).
Support aux transitions	Transition externe Transition locale Transition interne (dessinez une transition personnelle et changez le type de transition en interne) Achèvement Transition et Achèvement Événements Gardes de transition Transitions composées Priorités de tir et algorithme de sélection Pour plus de détails, reportez-vous à la Spécification UML UML .
Déclencheur et Événements	Un Statemachine Exécutable supporte la gestion des événements pour les signaux uniquement. Pour utiliser les types d'événements d'appel, de synchronisation ou de modification, vous devez définir un mécanisme externe pour générer des signaux en fonction de ces événements.
Signal	Attributes peuvent être définis dans Signaux ; la valeur des attributs peut être utilisée comme arguments d'événement dans Transition Gardes et Effets . Par exemple, voici le code défini dans l'effet d'une transition en C++ : si(signal->signalEnum == ENUM_SIGNAL2) { int xVal = ((Signal2*)signal)->maVal; } Signal2 est généré sous la forme de ce code : classe Signal2 : public Signal{ publique: Signal2(){}; Signal2(std::vector<String>& lstArguments); int maVal; }; Note : des détails supplémentaires peuvent être trouvés en générant un Statemachine Exécutable et en se référant au fichier « EventProxy » généré.
Initial	Un pseudo-état initial représente un point de départ pour une région. Il est la source d'au plus une transition ; il ne peut y avoir qu'un seul sommet initial dans une région.
Régions	Activation par défaut et activation explicite : Les transitions se terminent sur l' State contenant : Si un pseudo-état initial est défini dans la région : activation par défaut Si aucun pseudo-état initial n'est défini, la région restera inactive et l' State qui la contient sera traité comme un State simple Si la transition se termine sur l'un des sommets contenus dans la région : activation explicite , entraînant l'activation par défaut de toutes ses régions orthogonales, à moins que ces régions ne soient également saisies explicitement (plusieurs régions orthogonales peuvent être saisies explicitement en parallèle via des transitions provenant du même pseudo-état de fourche) Par exemple, s'il existe trois régions définies pour un State orthogonal et que les régions A et B ont un pseudo-état initial, alors la région C est explicitement activée. L'activation par défaut s'applique aux régions A et B ; l' State contenant aura trois régions actives.
Choix	Les contraintes de garde sur toutes les transitions sortantes sont évaluées de manière dynamique lorsque la traversée de transition composée atteint ce pseudo-état.
Jonction	Branche conditionnelle statique : les contraintes de garde sont évaluées avant l’exécution de toute transition composée.
Fourcher / Rejoindre	Non threadé, chaque région active se déplace d'une étape en alternance, en fonction d'un mécanisme de pool d'événements d'achèvement.
Nœuds de point d'entrée/point de sortie	Non threadé pour State orthogonal ou Statemachine orthogonale ; chaque région active se déplace d'une étape en alternance, en fonction d'un mécanisme de pool d'événements d'achèvement.
Nœuds d'histoire	DeepHistory : représente la configuration State active la plus récente de son State propriétaire ShallowHistory : représente le sous-état actif le plus récent de l' State qui le contient, mais pas les sous-états de ce sous-état
Événements différés	Dessinez une transition automatique et modifiez le type de transition en interne. Type « defer(); » dans le champ « Effet » pour la transition.
Références des points de connexion	Une référence de point de connexion représente une utilisation (dans le cadre d'un State de sous-machine) d'un point d'entrée/sortie défini dans la Statemachine référencée par l' State de sous-machine. Les références de point de connexion d'un State de sous-machine peuvent être utilisées comme sources et cibles de transitions. Elles représentent des entrées ou des sorties de la Statemachine référencée par l' State de sous-machine.
Comportements State	Les comportements State « entrée », « doActivity » et « sortie » sont définis comme des opérations sur un State . Par défaut, vous saisissez le code qui sera utilisé pour chaque comportement dans le champ Panneau 'Code' de la fenêtre Propriétés pour l'opération Comportement. Note que vous pouvez modifier cela pour saisir le code dans le panneau 'Comportement', en personnalisant le gabarit de génération. Le comportement « doActivity » généré sera exécuter jusqu'à son terme avant de continuer. Le code n'est pas simultané avec d'autres comportements d'entrée ; le comportement « doActivity » est implémenté comme comportement « exécuter dans la séquence après l'entrée ».

Références à des comportements dans d'autres contextes/classes

Si l' State de la sous-machine fait référence à des éléments de comportement en dehors du contexte ou de la classe actuels, vous devez ajouter un connecteur <<import>> de la classe de contexte actuelle à la classe de contexte du conteneur. Par exemple :

State de sous-machine S1 de la classe 1 fait référence à Statemachine ST2 de la classe 2

Par conséquent, nous ajoutons un connecteur <<import>> de la classe 1 à la classe 2 afin que la génération de code Statemachine Exécutable génère correctement le code pour State sous-machine S1. (Sur la classe 1, cliquez sur la flèche Quick Linker et faites-la glisser vers la classe 2, puis sélectionnez « Importer » dans le menu des types de connecteurs.)

Réutilisation d'artefacts Statemachine Exécutable

Vous pouvez créer plusieurs modèles ou versions d'un composant à l'aide d'un seul artefact exécutable. Un artefact représentant une résistance, par exemple, peut être réutilisé pour créer à la fois une résistance à feuille et une résistance à fil enroulé. Cela est susceptible d'être le cas pour des objets similaires qui, bien que représentés par le même classificateur, présentent généralement des états exécuter différents. Une propriété nommée 'resistorType' prenant la valeur 'wire' plutôt que 'foil' peut être tout ce qui est requis du point de vue de modélisation . Les mêmes Statemachines peuvent ensuite être réutilisées pour tester les changements de comportement qui pourraient résulter de la variation de l'état d'exécution. Voici la procédure :

Étape	Action
Créer ou ouvrir diagramme de composants	Ouvrez un diagramme de composant sur lequel travailler. Il peut s'agir du diagramme qui contient votre artefact d'origine.
Sélectionnez l' Statemachine Exécutable à copier	Recherchez maintenant l'artefact Statemachine Exécutable original dans la fenêtre Navigateur .
Créer le nouveau composant	Tout en maintenant la touche Ctrl enfoncée, faites glisser l'artefact d'origine sur votre diagramme . Deux questions vous seront posées. La réponse à la première question est Object et à la seconde, Tout. Renommez l'Artefact pour le différencier de l'original, puis modifiez ses valeurs de propriété.

Étape

Action

Créer ou ouvrir diagramme de composants

Ouvrez un diagramme de composant sur lequel travailler. Il peut s'agir du diagramme qui contient votre artefact d'origine.

Sélectionnez l' Statemachine Exécutable à copier

Recherchez maintenant l'artefact Statemachine Exécutable original dans la fenêtre Navigateur .

Créer le nouveau composant

Tout en maintenant la touche Ctrl enfoncée, faites glisser l'artefact d'origine sur votre diagramme . Deux questions vous seront posées.

La réponse à la première question est Object et à la seconde, Tout. Renommez l'Artefact pour le différencier de l'original, puis modifiez ses valeurs de propriété.