Le but de ce mini-projet est de générer le code Java à partir d'un diagramme de classes UML comportant un mini-langage d'action.
Le travail est à faire en binôme.
Dans la partie 1 du projet, vous devez terminer la génération de code Java pour le méta-modèle de diagrammes de classes vu en TP. Vous pouvez implémentez la génération en Acceleo ou en Java/EMF, au choix (bonus de points si cela est fait en Acceleo).
Il s'agit de générer le maximum de code possible. Dans la suite du projet, on s'intéressa à définir le contenu des méthodes.
Dans un premier temps, il s'agit de modifier le méta-modèle afin d'y rajouter les éléments permettant de définir un mini-langage d'action afin de définir le contenu des méthodes. On se limitera ici à manipuler des entiers ou des booléens. Dans un second temps, il s'agit de compléter la génération de code pour prendre en compte la définition du contenu des méthodes.
En détail, il faut pouvoir modéliser :
A titre d'exemple, voici une classe Java dont il devra être possible de générer le contenu à partir d'un modèle de diagramme de classes :
public class Compte {
private int solde = 0;
private boolean aDecouvert = false;
private int id = 0;
public void debiter(int somme) {
this.solde = this.solde - somme;
this.aDecouvert = this.solde < 0;
}
public void crediter(int somme) {
this.solde = this.solde + somme;
this.aDecouvert = this.solde < 0;
}
public Compte(int id) {
this.id = id;
}
public void setSolde(int solde) {
this.solde = solde;
}
public int getSolde() {
return this.solde;
}
}
Voici des classes Ecore que vous pouvez rajouter à votre méta-modèle (après adaptation) pour vous aider à définir le langage d'action. Editez le méta-modèle en mode textuel (Open With -> OCLinEcore Editor) pour rajouter ce contenu :
abstract class ExpressionElement;
class Expression extends ExpressionElement
{
property left : ExpressionElement[1] { composes };
property right : ExpressionElement[1] { composes };
attribute operator : Operator[1];
attribute _name : String[?];
}
enum Operator { serializable }
{
add;
sub = 1;
eq = 4;
mul = 2;
gt = 6;
lt = 8;
lte = 9;
gte = 7;
div = 3;
_'and' = 10;
neq = 5;
_'or' = 11;
_'not' = 12;
}
abstract class Data extends ExpressionElement;
class BooleanData extends Data
{
attribute value : Boolean[1];
}
class IntegerData extends Data
{
attribute value : ecore::EInt[1];
}
abstract class Variable
{
property value : Data[?] { composes };
attribute name : String[1];
}
class BooleanVariable extends Variable;
class IntegerVariable extends Variable;
class Operation
{
property contents : Assignment[*|1] { ordered composes };
attribute name : String[?];
}
class Assignment
{
property expression : ExpressionElement[1] { composes };
property variable : Variable[1];
attribute _name : String[?];
}
class VariableReference extends ExpressionElement
{
property variable : Variable[1];
attribute _name : String[?];
}
Voici quelques explications sur le rôle de ces classes :
Note : les attributs _name des éléments Expression et Assignment ou autres méta-éléments associés n'ont pas de sémantique particulière. Ils servent juste à pouvoir identifier les instances de ces éléments via un nom textuel ou préciser leur contenu donné sous forme textuelle afin de faciliter l'édition des modèles dans l'éditeur XMI par défaut.
La dernière partie du projet consiste à rajouter la manipulation d'objets en ayant la capacité d'instancier les classes et d'appeler des méthodes sur les objets.
A titre d'exemple, voici une classe Java dont il devra être possible de générer le contenu :
public class Banque {
private Set
public void addCompte(Compte cpt) {
this.comptes.add(cpt);
}
public void transferer(Compte source, Compte cible, int somme) {
source.debiter(somme);
cible.crediter(somme);
}
public static void main(String argv[]) {
Compte c1 = new Compte(1234);
Compte c2 = new Compte(5678);
c1.setSolde(2000);
c2.setSolde(1500);
Banque banque = new Banque();
banque.addCompte(c1);
banque.addCompte(c2);
banque.transferer(c1, c2, 500);
}
}
Vous m'enverrez par mail, pour Vendredi 12h30 dernier délai, une archive contenant votre méta-modèle Ecore modifié, des exemples de modèles que vous avez définis et le code Java ou Acceleo de votre génération de code. Je testerai chacun des projets donc précisez dans votre mail où vous en êtes arrivés de l'implémentation des fonctionnalités demandées et fournissez des générations de code qui s'exécutent.