OCL (Object Constraint Langage)

1. Introduction

UML est un langage de modélisation essentiellement graphique il est donc difficile de préciser de
manière complète tout les subtilités d’un modèle. OCL est une réponse à se problème puisque c’est
un langage formel qui permet l’expression de contrainte.

2. Objectifs d’OCL
 Accompagne les diagrammes UML avec des descriptions précises et non ambiguës.
 Entrer les désavantages des langages formels traditionnel càd : rester facile à écrire et a lire
(dans un style objet).

3. Historique

Développé en 1997 par IBM. Intégré à UML 1.1 en 1999.

4. Principes
4.1. Notion de contrainte

Une contrainte est une expression à valeur booléen que l’on peut attacher à n’importe quel élément
UML.

4.2. Langage déclaratif

Les contraintes ne sont pas opérationnelle (il y a que des requêtes).

4.3. Langage sans effet de bord

4.4. Utilisation des contraintes
 Les contraintes servent à plusieurs situations :
 Description d’invariants sur les classes.
 ‘’Pré condition’’ et ‘’post condition’’ sur les méthodes.
 Contraint sur les valeurs retournées par les méthodes.
 Règles de dérivations des attributs.
 Expression des gardes.
 Invariant de type pour les stéréotypes

5. Quelque contrainte simple

5.1. Notion de contexte 

Une contrainte OCL est liée à un contexte que le type, la méthode ou l’attribut auquel la contrainte
se reporte.

5.1.1.Syntaxe
context nom contexte < stéréotype>¿

expression de la contrainte

Le stéréotype peut prendre les valeurs suivantes :

 INV : invariante.
 Pré : pré condition.
 Post : post condition.
 Body : indiqué les résultats d’une opération query.
 INIT : indiqué la valeur initiale d’un attribut.
 DERIVE : indiqué la valeur dérivée d’un attribut.

Exemple :

Personne
Pour indiqué qu’un
attribut est dérivé -age : entier
-/majeur : booléen
(Calculer à partir
d’autre attribut) +getage() :entier{query}
+setage()(in a :entier)

 Définie les contraintes suivants dans le contexte de la classe personne : 0<Age<140

Context Personne INV :

(age<=140) and (age>=0)- - l’âge ne dépasse pas 140ans

 contextes des méthodes getage() et setage() :

Context Personne ::setage(a :integer)
Pre: (a<=140) and (a>=0) and (a>age).
Post: age = a.

Context Personne ::getage():integer

Body: age.
 contrainte dans le contexte d’un attribut :
o sur attribut age :
Context Personne :: age :integer
INIT : 0

o Sur attribut majeur :

Context Personne :: majeur :bolean
DERIVE : age>=18.

5.2. Vision visuelle

Personne
« Invariant »
-age : entier
(age<=140
-/majeur : booléen
and age>=0)
+getage() :entier{query}
+setage()(in a :entier)

5.3. Contrainte nommée 

Une contrainte peut être nommée se sera utile pour rappeler la contrainte dans une
autre plus Complexe
Exemple :
Context Personne INV ageBorné :
(age<=140) and (age>=0)

5.4. Désignation de l’objet

Le mot clé « Self » permet de désigner l’objet a partir du quel part l’évaluation.
Exemple :
Context personne INV :
(Self.age<=140) and (Self.age>=0).
5.5. Utilisation d’un nom formel de l’objet
a) Context p=Personne INV :
(p.age<=140) and (p.age>=0)

b) ajouter dans la classe personne un attribut « mère : Personne »

 Écrivez une contrainte précisant que la mère d’une personne ne peut pas être cette
personne elle-même et que l’âge de la mère doit être supérieur à celui de la personne :

Context Personne INV :

(Self. Mère<>Self) and (Self.mere.age>Self.age)

6. Les types dans OCL

A
T
V
O
o
B
S
l
c
e
é
R
o
M
l
c
O
ti
E
n
i
r
t
S y
l
n
o
é
a
t
l
E
l
e
d
g
e
r
y
p
d
i
n
e
t
t
n
m
e

O
S
V
l
c
q
e
d
C
O
l
o
r
e e
u
o
ti
c
e
r
B
a
g
S
e
t
d
i
n
e
c
o
d
n
t
e
S
 6.1. Les types de base

Type Ses opérateurs

Entier = < > <= >= + - * / ans div mod max min
Réel Round floor
String Size concat toUpper toLower substring
Booléen Xor or and not implies
6.2. Expressions de base
6.2.1.La clause de decision

if b then
………………………..
else
…………………
endif

6.2.2.La clause de “implies”

B1 implies b2

6.2.3.Exemple

P e rs onne

- a ge : int
- m a je u r : boole a n
- m a rie : boole a n
- /ca te gorie : e num {e nfa nt, a d o, a dult}

Une personne mariée est une personne majeure

context Personne inv :

marie implies majeur
Une personne majeure est une personne ayant plus de 18 ans.

context Personne inv :

if (age>=18) then
majeur=true
else
majeur=false
endif

context Personne inv :

majeur=(age>=18)

L’attribut « categorie » dérive de l’attribut « age »

context Personne:categorie inv :

context Personne inv :
if (age<=12) then #enfant
if (age<=12) then categorie=#enfant
else if (age<=18) #ado
else if (age<=18) categorie=#ado
else #adult
else categorie=#adult
endif
endif
endif
endif

7. Navigation
7.1. Accès aux attributs et aux opérations

P e rs onne
- a ge : int
+ <<Ge tte r>> ge ta ge () : int
+ <<S e tte r>> se ta ge (int ne wAge ) : void

Voiture
- P roprie ta ire : P e rs onne

Le propriétaire d’une voiture est une personne majeure.

context Voiture inv :

self.proprietaire.age>=18
 7.2. Accès aux extrémités d’une relation

P e rs onne

- a ge : int
+ <<Ge tte r>> ge ta ge () : int
+ <<S e tte r>> se ta ge (int ne wAge ) : void

0..1
proprié ta ire

0..*
proprié té

Voiture

Ça se fait soit en utilisant les noms des rôles, soit avec les noms clases voisines (extrémités) en
mettant leurs première lettre en minuscule à condition qu’il n’y a pas d’ambiguïté.

context Voiture inv :

self.propriétaire.age>=18

7.3. Navigation dans les classes d’associations

Pour naviguer vers une classe d’association, on utilise le nom de la clase en mettant le premier
caractère en minuscule.

Enca d re m e nt
- de but : Da te
- fin : Da te

Entre pris e

0..1
* re s pon s a ble
e m plo ie

* P e rs onn e
e m ployé 0..1
a ge nt de s e cre ta ria t

Contra t

- type : boole a n
- da te : Da te
- s a la ire : double

Le salaire d’une personne doit être positif ou nul.

 context p :Personne inv :
p.contrat.salaire>=0

Une autre manière de naviguer consiste à utiliser le nom de rôle opposé. C’est intéressant et
obligatoire dans le cas d’une association réflexive.

Le salaire d’un agent de secrétariat est inferieur à celui de son responsable.

context e :Encadrement inv :

e.responsable.contrat.salaire>=e.agentSecretariat.contrat.salaire

7.4. Navigation depuis les classes associations

Pour naviguer depuis une classe d’une association, on utilise les extrémités d’une association, on
utilise les noms de rôles, s’il y’en a pas le nom de la classe fera l’affaire, tout en mettant sa première
lettre en minuscule.

Déclarez que l’âge des employés doit être supérieur ou égal à 16 ans.

context Contrat inv :

employé.age>=16

Un agent de secrétariat possède un contrat de type agent administratif

context e :Encadrement inv :

e.agentSecretariat.contrat.typeContrat= « Agent Administratif »

Un agent de secrétariat a une date d’embauche antérieure à la date de début de l’encadrement.

 context e :Encadrement inv :
e.agentSecretariat.contrat.dateEmbauche<=e.dateDebut

8. Importance du contexte

C1
0..* C2
- a ttr1 : boole a n
- a ttr2 : boole a n
0..1

0..1

0..*

C3

- a ttr3 : boole a n

context C1 inv :
c2.attr2=c2.c3.attr3

context C2 inv :
attr2=c3.attr3

La première contrainte dit que pour des instances de c23 et c3 liés à une instance c1, les attributs 2
et 3 sont égaux et n’impose rien à des instances de C2 et C3 non liés à une instance de C1.

La deuxième dit que tous couples d’instances de C2 et C3 liés, ces deux attributs sont égaux.

Nous voyons ainsi que le contexte dans lequel, on décrit les contraintes est fondamental.

9. Compléments d’OCL
 Entre pris e P e rs onne
0..1 *
e m ploye ur e m plo yé - a ge : int 0..1
+ <<Ge tte r>> ge ta ge () : int Age nt S e cre ta ria t
+ <<S e tte r>> s e ta ge (int ne wAge ) : void
+ fe te _a nnive rs a ire () : void

Contra t
0..1
- type Contra t : S trin g
Re s pons a ble
- da te : Da te
- s a la ire : floa t

Enca d re m e nt

- Da te De b ut : Da te
- Da te Fin : Da te

9.1. Autres mots clés

9.1.1.Désignation de valeurs antérieures

Décrire la méthode représentant la fête d’anniversaire d’une personne tout en spécifiant l’âge
antérieur et le nouvel âge.

context Personne ::fete_anniversaire()
pre : age<140
post : age=age@pre+1

9.1.2.Définition des variables et des opérations

9.1.2.1. let

let variable : type=expression1 in

expression2

En ajoutant l’attribut impot, on pourra écrire la contrainte suivante :

 context Personne inv :
let mI :real=contrat.salaire*1.10 in
if (mI>100000) then impot=mI*0.50
else if (mI>50000) then impot=mI*0.40
else impot=mI*0.30
endif
endif

9.1.2.2. def
9.1.2.2.1. Pour les variables

si on veut définir une variable pour tout un ensemble de contraintes, on doit utiliser « def » au lieu
de « let », car le « let » n’a comme durée de vie pour ses variables que la contrainte elle-même.

context Personne
def mI :real=contrat.salaire*1.10

9.1.2.2.2. Pour les opérations

Il est très utile des fois de définir des opérations, on peut procéder avec la même construction
« def ».

Définissez une opération ageCorrect(), pour la classe Personne.

context Personne
def : ageCorrect(a :real):Boolean=(a>=0)and(a<=140)

context Personne::setAge(a:real)
pre: ageCorrect(a)and(a>age)

context Personne inv:

ageCorrect(age)

9.1.3.Retour d’opérations

Décrire la post condition de la méthode getAge().

 context Personne ::getAge() :integer
post : result=âge

context Personne ::getAge() :integer
body : age

Les deux contraintes définies ci-dessus sont équivalentes sauf que l’une utilise le body tandis que
l’autre utilise le result dans un post.

On peut proposer une classe Etudiant qui se constitue de trois notes N1, N2 et N3, puis on devrait lui
ajouter une méthode nous retournant une chaine de caractères décrivant sa mention.

context Personne ::mention() :string
post : let moy :real=(N1+N2+N3)/3 in
if (moy>=16) then result=”très bien”
else if (moy>=12) then result=”bien”
else result=”a bien”
endif
endif
 9.2. Collection

e
q
S
l
o
e
d
r
C
O e
u
ti
c
e
r
B
a
S
e
t
e
c
n
n
e
S
o
d g
t

 Set : un ensemble non ordonné (pas de doublons)

 Ordered Set: un ensemble ordonné.
 Bag : famille ordonné (peut avoir des doublons).
 Sequence : famille non ordonné.

9.2.1.Opérations de collection

Soit des collections d’éléments de type T

9.2.1.1. Appelle

On utilise l’opérateur « » pour appeler une opération appliqué à une collection

9.2.1.2. Itération

Opération (V|expression contenant V)

Ou

Opération (V : type| expression contenant V)

9.2.1.3. Quelque opérateur

 Savoir si une collection est vide :
o isEmpty():Booléen
o notEmpty():Booléen

Exemple:

Context p : Personne inv :

p. agent Secrétariat notEmpty()

 Size () : donné la taille d’une collection (nombre de collection).
implies

p. agent Secrétariat.contrat.dateEmbauche<=p. encadrement[agent Secrétariat].datedebut

  Count (objet : T) :integer ,pour donner le nombre d’occurrence d’un objet T dans
une collection.
 Sum () : T, addition des éléments de la collection, il faut bien entendu que le type
de l’objet T est sommable.
 Includes (unObjet : T) : Booléen, pour savoir si l’objet appartient à la collection.
 Exclude (unObjet : T) : Booléen, pour savoir si l’objet n’appartient pas à la
collection.
 ForAll (uneExpression: Booléen) :Booléen, vérification d’une propriété pour tous
les éléments d’une collection.

Ou ForAll (t1,t2 :T une expression contenant t1 et t2).

 Exists (uneExpression: Booléen) :Booléen, vérifie l’expression pour au moins un

élément.
 One (uneExpression: Booléen) :Booléen, vérifie l’expression pour un et un seul
élément.