Nous avons ensuite dû choisir une manière de modéliser les ressources nécessaires au processus de développement.
Notre choix de modélisation s’est porté sur : une Ressource (qui implémente ProcessElement) est demandée par le biai d’une Request elle-même générée par une WorkDefinition.
On se retrouve donc avec un nouveau modèle Ecore de la forme :
Les relations Ressource-Request et Request-WorkDefinition sont déclarées en EOpposite pour pouvoir facilement passer d’un fils à un parent et vice versa.
Le modèle SimplePDL est maintenant complet pour représenter des processus de développement.
Un exemple complet d’utilisation de ce modèle serait :
En se basant sur ce que l’on a vu pour le modèle SimplePDL, nous avons créé un modèle Ecore permettant de modéliser les réseaux de pétri.
Nous avons modélisé un réseau comme étant composé de nœuds.
Ces nœuds peuvent être les places ou des transitions.
Ils sont donc nommés et reliés entre eux par des arcs.
Ses arcs ont un attribut entier nommé weight pour indiquer le poids de l’arc ainsi qu’un boolean outgoing pour indiquer si ce dernier est dirigé d’une Place vers une Transition ou d’une Transition vers une Place.
(Si outgoing est vrai, alors l’arc va de la transition vers la place.)
Pour les modèles SimplePDL, nous contraignons les noms des Process au format camelCase. De même les noms des WorkDefinitions et des Resources doivent posséder au minimum 2 caractères et ne pas être exclusivement constitués de chiffres ou d'underscores.
Nous avons aussi contraint l’utilisateur à utiliser les WorkSequence sur des WorkDefinition appartenant au même Process. Pour éviter des non-sens, les WorkSequence ne peuvent pas non plus avoir le même successeur et prédécesseur.
\begin{textcode}
context WorkSequence
inv successorAndPredecessorInSameProcess('Activities not in the same process : '
+ self.predecessor.name + ' in ' + self.predecessor.process().name+ ' and '
+ self.successor.name + ' in ' + self.successor.process().name):
Nous avons aussi ajouté des contraintes sur les quantités des Resource et Request.
En effet, cela n’a pas de sens d’savoir des Resource ou des Request avec des quantités négatives. De plus, une Request ne peut pas être plus grande que le nombre initial de ressources. (Le nombre initial de ressources est le maximum puisqu’il n’y a pas de création.)
Pour permettre une meilleur intégration de nos métamodèles dans notre environnement de developpement (sous Eclipse), nous pouvons créer des greffons nous permetttant de les intégrer dans d'autres projets, ainsi que des éditeurs arborescents nous permettant de mieux visualiser/éditer des modèles conformes à nos métamodèles Ecore.
Le code java de ces éditeurs arborescent est engendré par nos métamodèles Ecore, mais nous pouvons le modifier manuellement pour que ceux-ci conviennent parfaitement à nos critères.
Ces plugins seront déployés dans une Eclipse Application séparée de notre environnement de developpement principale pour ne pas mélanger métamodèles et modèles.
Maintenant que nous pouvons charger plus facilement nos métamodèles dans notre environnement de travail, il nous est aussi possible d'importer nos modèles dans un programme Java (grâce aux modules générés automatiquements par EMF). Ainsi en 300 lignes de code, nous pouvons convertir directement un modèles simplePDL en un modèle petriNet.
Il nous est possible de transcrire nos modèles vers d'autres formats de fichiers pour nous permettre de les utiliser dans logiciels tierces, et ainsi de les modifier/visualiser plus aisaiment.
Tout comme lors de la création d'éditeurs arborescent spécifiques à nos métamodèles (cf EMF), il nous est possible de créer des éditeurs graphiques pour nos métamodèles. Cela nous donne accès à des outils graphiques permettant ainsi à un utilisateur non accoutumé à des outils complexes de créer et modifier des modèles (de processus ou de réseau de petri).
Dans la continuité de la création d'outils pour manipuler et visualiser nos modèles, il nous est possible de définir une styntaxe textuelle associée à nos métamodèles.
Ainsi pour simplePDL, la syntaxe textuelle suivante permet de manipuler nos modèles facilement, sans passer par des outils graphiques parfois complexes.
Finalement il nous est possible, tout comme lors de la transformation modèle à modèle via l'écriture d'un programme Java, de transformer un modèle selon un autre métamodèles via l'outil ATL.
\caption{Modèle pour la transformation de modèle à modèle}
\label{transfo}
\end{figure}
Pour transformer une WorkDefinition dasn un réseau de Petri, nous créons 4 places (\_idle, \_running, \_started, \_finished) ainsi que 2 transitions (\_start, \_finish).
Pour transformer une WorkSequence, nous relions la place du predecesseur à la transition du successeur, par exemple dans le cas d'un linkType start2start nous relions un \_started à un \_start.
Pour transformer une Resource, nous créons simplement un palce avec le bon nombre de tokens. Pour ce qui est des Requests d'une WorkDefinition nous relions le \_start et le \_finish de la WorkDefinition à la ressource avec les poids correspondants.
Dans l'optique d'une vérification de la terminaison et de la transformation correcte de notre modèle simplePDL en modèle petriNET, nous pouvons à partir du modèle simplePDL générer des propositions que nous demanderons par la suite à selte/tina de vérifier. \\
Pour vérifier la terminaison du processus, nous pouvons écrire:
