Conception modulaire les paquetages

Conception modulaire

Spécification, conception, documentation s’exprime en UML (Unified Modelling Language)
L’application est découpée en entités distinctes
CompagnieAerienne propose
1..* 1..*
Un module permet de nommer un environnement et de manipuler comme un tout un environnement fermé
Vol
dateDepart heureDepart dateArrivee heureArrivee
ouvrirReservation()
fermerReservation()

Abstraire des données (1)

Le concept de procédure permet d’abstraire (d’un contexte particulier) une suite d’instructions et donc d’enrichir le langage d’une nouvelle instruction
Le concept de module (paquetage) permet au programmeur d’enrichir le langage avec de nouveaux types de données
Un module rassemble :
– la déclaration d’un type de données
– les opérations de manipulation des valeurs de ce type
Un module est divisé en 2 parties :
– La première définit l’interface (point de vue utilisateur du type de données) et regroupe les déclarations des opérations sur ce type
– La seconde définit l’implantation du type (point de vue développeur). Elle regroupe les déclarations des corps des fonctions et procédures qui manipulent les valeurs de ce type

Encapsulation et masquage de l’information

Ces deux mécanismes du langage réalisent l’abstraction de données.
L’encapsulation permet la réunion des points de vue client et serveur
Le masquage de l’information (data hiding) empêche l’utilisateur d’avoir accès à la réalisation des opérations du module
L’utilisateur a accès au ¨quoi¨ d’un type de données sans avoir à se préoccuper du ¨comment¨.

Paquetage Ada : interface (1/3)

Syntaxe
<déclaration_interface_paquetage>::=
package <ident_paquetage> is <liste_déclarations>
end <ident_module>
Exemple
package Vecteur is
type Vect_int is array (Positive range <>) of Integer;
function ¨+¨(U,V:Vect_int) return Vect_int; function ¨*¨(U:Vect_int;N:Integer) return Vect_int; procedure put(X:in Vect_int);
end Vecteur;
Sémantique
–L’évaluation de la déclaration d’un paquetage a pour effet de
lier l’identificateur du paquetage à l’environnement qu’il construit
–L’environnement est construit à partir des déclarations contenues dans l’interface
–Evaluation dans env :
Ajout de la liaison (ident,??) à env
Évaluation de la valeur d’environnement => évaluation de l’ensemble des déclarations du paquetage et création des liaisons correspondantes
Remplacement de la valeur indéfinie (??) par la valeur de l’environnement
env
(Vect_int, définition du type)
(+,??) )
(Vecteur, (*,??)
(put,??)

Paquetage Ada : implantation

Syntaxe
<déclaration_corps_paquetage>::= package body <ident_paquetage> is
<liste_déclarations>
begin
<suite_instructions>
exception
<traitement_exceptions>
end <ident_paquetage>

Implantation : exemple (1/4)

package body Vecteur is
function « + »(U,V:Vect_int) return Vect_int is W:Vect_int(V’range);
begin
for i in U’range loop
W(i):=U(i)+V(i);
end loop;
return W;
end « + »;
function « * »(U:Vect_int;N:Integer) return Vect_int is W:Vect_int(U’range);
begin
for i in U’range loop
W(i):=U(i)*N;
end loop;
return W;
end « * »;
procedure put(X:in Vect_int) is begin
for i in X’range loop
put(X(i));put(« , »);
end loop;
end put;
end Vecteur;
Sémantique (évaluation dans env’)
1. Détermination des fermetures des fonctions et procédures déclarées dans l’interface
1. Modification des liaisons correspondantes dans la valeur d’environnement
env
(Vect_int, définition du type)
(Vecteur, (+,<<U,Vcorps de +, env’>>) )
(*,<<U,Ncorps de *, env’>>)
(put,<<Xcorps de put,env’)

Opérations sur les paquetages

Pour rendre visible un objet déclaré dans un paquetage, on utilise l’opérateur . :
<op_acces_objet>::=<ident_paquetage>.<ident_objet>
Evaluation
1. Recherche de la liaison (ident_paquetage,valeur d’env) dans l’environnement courant
2. Soit env la valeur d’environnement trouvée, recherche dans env de la liaison (ident objet, valeur d’objet)

Exemple d’accès à un paquetage

Accès à un type
Vect:Vecteur.Vect_int(1..4):=(3,8,8,6);
Accès à une opération
vect:Vecteur. »+ »(vect,vect);
ou
use Vecteur;
vect:=vect+vect;
Partie privée
Partie publique
Une interface de paquetage possède une partie privée et une partie publique :
<déclaration_interface>::= package <ident_paquetage> is
<liste_déclarations>
private
<liste_déclarations>
end <ident_paquetage>;
La partie publique est visible de l’extérieur. Elle décrit l’ensemble des objets disponibles pour un client.
La partie privée contient les déclarations des objets privés à usage exclusif du paquetage

Types privés (1/2)

Intérêt : la déclaration du type est publique, sa définition est cachée aux utilisateurs extérieurs
On peut ainsi modifier la définition d’un type sans avoir à modifier les programmes qui utilisent ce type
La définition d’un type privé est donnée dans la partie private de l’interface du paquetage. Elle est donc visible mais inutilisable de l’extérieur du paquetage
Syntaxe
<déclaration_type_privé>::=
type <ident_type> is private;
Opérations disponibles pour un utilisateur extérieur :
1. Les opérations sur ce type déclarées dans la partie publique
2. L’affectation (:=), l’égalité (=), l’inégalité (/=)

Types privés et intégrité des données

A un type (ensemble de valeurs) est associé un ensemble de sous-programmes (procédures et fonctions) qui opèrent sur lui.
Aucun autre sous-programme ne doit pouvoir agir sur ce type pour porter atteinte à l’intégrité des valeurs de ce type.