## Positionnement des classes et associations

- Chaque ligne constitue la définition d'une *boîte* (classe ou association).
- Les boîtes définies sur des lignes consécutives sont tracées sur une même rangée.
- Un saut de ligne commence une nouvelle rangée.
- Les boîtes sont alignées verticalement. Une ligne réduite à un deux-points 
(`:`) insère une boîte invisible (saut de colonne).
- Ce qui est entre `/*` et `*/` ou ce qui suit `//` est ignoré (commentaire).



## Définir une classe

```plaintext
classe: attr1, attr2, attr3, ...
```

- Le nom de la classe est suivit par un deux-points.
- Les attributs sont séparés par des virgules.
- Le premier attribut est par défaut l'identifiant de la classe. Pour inclure 
un autre attribut dans l'identifiant (ou exclure le premier), préfixer le 
nom de l'attribut par un tiret bas ;  
exemple : `_attr`
- Le type de donnée peut être précisé entre crochets après le nom de l'attribut 
(la valeur par défaut est `VARCHAR(50)`). Le type `COUNTER` est un mot clé 
pour définir un nombre auto-incrémenté ;  
exemple : `attr [INT]`

### Spécificités UML / OOP :

- La visibilité des attributs est par défaut protégée. Des accesseurs et mutateurs 
sont automatiquement générés à moins que la visibilité ne soit rendue explicite 
par le préfixe `+` (publique), `#` (protégée) ou `-` (privée)
- Un attribut préfixé par `~` est à portée classe.
- Le type `T` indique un type générique.



## Définir une association

```plaintext
assoc, 01 ent1, 1N ent2, ... : attr1, ...
```

- Le nom de l'association est suivit par une virgule.
- Les "pattes" d'une association sont séparées par des virgules.
- Chaque patte est définie par ses cardinalités (`01`, `11`, `0N`, `1N`, ou 
`XX` pour les masquer) suivies du nom de la classe impliquée dans l'association.
- Les éventuels attributs d'une association sont placés à la fin après un 
deux-points.
- Le rôle de que joue la classe dans l'association peut être indiqué entre 
crochets, après les cardinalités ;  
exemple : `11 [role] entité`
- Pour indiquer un lien relatif, préfixer les cardinalités (dont la maximum 
devrait être 1) par un tiret bas ;  
exemple : `_11 entité faible`

### Spécificité UML / OOP :

- Pour indiquer une agrégation préfixer les cardinalités par la lettre `o` 
(en minuscule) ; le tiret du bas `_` (cf lien relatif) ou l'étoile `*` indique 
une composition.
- La visibilité des liens (par défaut protégée avec accesseurs et mutateurs) 
peut être rendue explicite en préfixant les cardinalités par `+`, `#` ou `-`.



## Définir une sous-classe

```plaintext
/\ parent - enfant1, enfant2
```

- La ligne commence par les caractères `/` et `\` suivis du nom de la classe 
parent, d'un tiret (`-`) puis des noms des classes enfants (sous-classes) 
séparées par des virgules.
- Des contraintes d'e`X`clusion  et/ou de `T`otalité peuvent être placées 
entre les `/` et `\` ;  
exemple : `/XT\ Personne - Eleve, Prof`
- Le séparateur entre parents et enfants permet de spécifier un choix pour 
la génération du modèle relationnel :

	- `-` pour générer la relation parent et une relation par enfant ;
	- `< [champCodeType]` pour supprimer les relations enfants et en faire
	remonter les attributs vers celle du parent (`[champCodeType]` est facultatif) ;
	- `>` pour supprimer la relation parent (en cas de `T`otalité) et en faire 
	 descendre les attributs vers celles des enfants (requiert e`X`clusion).



## Définir les méthodes d'une classe (spécificités UML / OOP)

*Les méthodes doivent être définies séparément et après la classe et ses attributs. 
Elles ne constituent pas des boîtes.*


```plaintext
classe(): méthode(param [type]) [type], ...
```

- Pour définir les méthodes d'une classe, indiquer le nom de la classe suivi
de parenthèses (il peut y avoir plusieurs lignes pour une même classe).
- Un nom de méthode est suivi par la liste de paramètres entre parenthèses, 
et du type de la valeur retournée (entre crochet) le cas échéant.
- Par défaut, le type des paramètres est déduit de celui des attributs (si 
le paramètre porte le même nom) ou est chaîne de caractères.
- Par défaut, un constructeur prenant la valeur de chaque attribut en paramètre 
est automatiquement généré, à moins qu'un constructeur ne soit explicitement 
défini sous la forme d'une méthode sans nom ;  
exemple : `classe(): (attr, attr)`
