- Menu
- Modeles
Dans cet exemple, on va utiliser des parcours pour manipuler des instances d'un méta-modèle de classes, version très simplifiée du MOF, destinée à la génération automatique de squelettes d'applications.
Modèle de base
Le méta-modèle de base est constitué des entités suivantes:
- des applications : une application contient un ensemble de classes
- des classes: celles-ci peuvent être primitives, auquel cas elles sont juste distinguées par leur nom. Dans le cas contraire, une classe contient des attributs
- des attributs : un attribut possède un nom, un type qui est une référence sur une classe et une multiplicité
Applications
Une application est une simple collection nommée de classes :
private String name; private Set<Klass> classes = new HashSet<Klass>();
Classes et types
Un type est caractérisé par son nom.
private String name;On utilise le nom comme clé pour identifier le type de sorte que deux types portant le même nom ne peuvent exister dans une même application. En Java, cela se traduit par une redéfinition des méthodes equals(Object) et hashcode().
previous public boolean equals(Type t) { return t.name.equals(name); } public int hashCode() { return name.hashCode(); } }
Un type est soit un type primitif, soit une classe.
public class Primitive extends Type { public Primitive(String name) { super(name); } }
Une classe est caractérisée par ses attributs, en plus de son nom.
private Set<Attribute> attributes = new HashSet<Attribute>();
Attributs
La classe la plus complexe est la classe définissant les attributs. Un attribut est caractérisé par:
- son nom
private String name;
- son type. Ce peut être un type primitif ou une classe.
previous private Type type;
- sa multiplicité. Il s'agit d'une constante numérique qui peut-être One, OneOrMore, OneOrZero, ZeroOrMore. Un attribut de type primitif ne peut avoir OneOrZero comme multiplicité.
previous private Multiplicity multiplicity;
Mise en oeuvre
On définit une instance simple de ce modéle, une application de prêt de livres.
On définit tout d'abord quelques types primitifs et les classe utilisées:
public void test01Dump(){ // primitive types Primitive string = new Primitive("String"); Primitive date = new Primitive("Date"); // some classe Klass book = new Klass("Book"); Klass person = new Klass("Person"); Klass loan = new Klass("Loan");
La classe Book représente les livres empruntés. Un livre possède un titre, un ou plusieurs auteurs et est prêté ou non.
previous book.add(new Attribute("title",string)); book.add(new Attribute("authors",string,Multiplicity.OneOrMore)); book.add(new Attribute("loans",loan,Multiplicity.OneOrZero));
Une personne est identifié par ses noms et prénoms, son email et les différents emprunts qu'elle a en cours.
previous person.add(new Attribute("firstName",string)) .add(new Attribute("lastName",string)) .add(new Attribute("email",string)) .add(new Attribute("loans",loan,Multiplicity.ZeroOrMore));
Un emprunt, enfin, concerne une personne et un livre, avec une date de départ et une date de retour.
previous loan.add(new Attribute("dateout",date)) .add(new Attribute("duedate",date)) .add(new Attribute("person",person)) .add(new Attribute("book",book));
L'application peut maintenant être définie comme constitué de livres, de personnes et d'emprunts.
previous Application app = new Application("Books"); app.add(book).add(person).add(loan); this.application = app;
Une traversée de base d'un tel modéle consiste simplement à imprimer les différents éléments qui le composent:
previous Traversal<String,Object> tr = new Traversal<String,Object>() { public String traverse(Object target) { String s = target.getClass().getName(); int i = s.lastIndexOf('.'); return s.substring(i+1); } }; EverywhereTD<String,Object> ev = new EverywhereTD<String,Object>(tr,new FIFOStore<Object>()); System.err.println(ev.traverse(application)); } }