L`IDL - Free

Agenda
†
†
†
†
†
†
†
†
†
†
†
†
2- L’IDL
Thierry DESPRATS
Université Paul SABATIER – Toulouse III
IRIT- SIERA
http://www.irit.fr/~desprats
[email protected]
Principales caractéristiques
Eléments syntaxiques
Types simples
Types complexes
Compléments sur les types
Interfaces
Opérations
Attributs
Exceptions
Modules
Structuration d’un fichier IDL
Illustration
IDL CORBA
© 2005-06 Th. Desprats
Principales caractéristiques (1/2)
Principales caractéristiques (2/2)
† Un langage descriptif…
† Fortement typé…
„
„
„
Langage purement descriptif de services offerts
= = > spécifier échanges et interactions entre client et serveur en
faisant abstraction des langages de programmation
en phase de modélisation et d’analyse
= = > passerelles UML vers IDL
syntaxiquement proche de C/C++
„ Le typage concerne l’expression des types des
paramètres et des retours d’opérations et d’attributs.
„ hiérarchie des types de l’OMG/IDL :
Valeur IDL
Types dynamiques
Any
Types d'objets
héritage…
Types simples
Short, Ushort
Long, Ulong, LongLong, UlongLong
Float, Double, LongDouble
Char, Wchar
String, Wstring
Boolean, Octet
Types complexes
Enum
Struct
Union
Array
Sequence
† À base d’interfaces…
„
La notion d’interface constitue le coeur d’IDL
= = > ensemble de prototypes de méthodes présentant une vue
fonctionnelle d’un objet (comportement, contrat)
† Orienté Objet…
„
„
„
IDL CORBA
L’héritage : une interface peut hériter d’une ou plusieurs autres
interfaces (héritage multiple sans ambiguïté de nom)
= = > héritage de déclarations seulement
= = > pas de redéfinitions possibles de méthodes
= = > possibles pour les constantes, noms et types des exceptions
L’encapsulation : pas d’élément d’implémentation
Le polymorphisme : possibilité d’associer plusieurs implémentations à
une même interface (non classique : pas de redéfinition de méthodes virtuelles)
© 2005-06 Th. Desprats
3
2
IDL CORBA
© 2005-06 Th. Desprats
4
1
Eléments syntaxiques (1/2)
Eléments syntaxiques (2/2)
† Identificateurs
† Préprocesseur
„
„
„
† Commentaires
„
„
„
„
„
„
Ils sont constitués par une séquence de caractères
alphanumériques et _.
Ils débutent obligatoirement par une lettre.
Respect de la casse (Livre diffère de livre).
/* gdsiuydsg
hfjds*/
any
Attribute
boolean
case
char
const
context
default
double
ƒ
ƒ
ƒ
ou //commentaire jqa fin de la ligne
† Mots clés :
enum
exception
FALSE
float
in
inout
interface
long
module
Object
octet
oneway
out
raises
readonly
sequence
short
string
IDL CORBA
struct
switch
TRUE
typedef
union
unsigned
void
wchar
wstring
© 2005-06 Th. Desprats
5
identique à celui de C/C++
substitution de macros (#define)
compilation conditionnelle (#ifdef et #ifndef)
inclusion de sources (#include)
directives de compilation (#pragma)
prefix : indique un préfixe à utiliser lors de la génération des identifiants,
version : associe un numéro de version à une définition IDL,
ID : fixe précisément l'identifiant associé à une définition IDL
= = > identification dans le référentiel des interfaces
† Eléments syntaxiques :
„
„
„
„
„
„
„
types de base et construits
interfaces
opérations (méthodes)
constantes
exceptions
attributs
modules
IDL CORBA
© 2005-06 Th. Desprats
Les types simples
Les types complexes
† Récapitulatif :
† Enumérations
IDL CORBA
Types de base
Valeurs
short
unsigned short
long
unsigned long
long long
unsigned long long
float
double
long double
boolean
octet
char
wchar, wchars
string, string<taille>
wstring
void
entiers 16 bits signés
entiers 16 bits non signés
entiers 32 bits signés
entiers 32 bits non signés
entiers 64 bits signés
entiers 64 bits non signés
flottants 32 bits IEEE
flottants 64 bits IEEE
flottants 128 bits
booléens
octets 8 bits
caractères 8 bits ISO Latin-1
caractères au format international
chaînes de caractères
chaînes de caractères au format international
type indéfini
© 2005-06 Th. Desprats
„
„
„
6
enum <identificateur> { <id1>, <id2>,…}
enum minerai { fer, or, argent, cuivre };
Lorsque les valeurs d'un type sont symboliques et complètement
connues dès la phase de conception
† Structures
„
„
struct <ident.> { <type_IDL_champ_1> <id_champ1> ;
<type_IDL_champ_2> <id_champ2> ; …}
struct identite {string nom; unsigned short age;};
† Tableaux
7
IDL CORBA
„
„
<type_IDL> [<cste_entier_positif>]
long Vecteur[200]; double Matrice[5][5];
„
„
„
sequence < <type_IDL> [,taille_max] > <identificateur>
sequence < Object > Remote; sequence <boolean,120> Grille;
Ensemble (une seule dimension possible) dynamique de valeurs
homogènes dont le nombre d'éléments est fixé seulement à
l'exécution (on peut optionnellement préciser une taille maximale).
© 2005-06 Th. Desprats
8
2
Compléments sur les types
†
Alias de type
„
„
„
†
Les Interfaces
† Déclaration
Permettre la(re)définition d’un type
typedef <type_IDL> <identificateur_alias>
typedef string<20> Prenom ;
†
†
Référence d’objet CORBA
„
„
„
Permettre le passage de références d’objets CORBA en paramètres ou en retour
d’opérations
Mot clé Object
…
prenom GetSurname(in Object o);
// o formalise une IOR d’un objet CORBA
Object FindIOR (in Prenom p);
// Cette opération retourne une IOR au client
†
†
† Héritage
†
…
„
†
„
„
†
Toute interface déclarée définit un type héritant de Object
†
Type indifférencié (ou Meta Types)
„
Type vide
„
„
Possibilité d’utiliser des types de données dynamiques et auto
- descriptifs (ils
contiennent une valeur et une information décrivant le type de la valeur)
Permettre de passer en paramètre n’importe quel type
Mot clé Any
© 2005-06 Th. Desprats
L’héritage ne concerne que la définition et non l’implémentation
= = > relation de sous-typage
héritage multiple possible, pas de surcharge, de duplication de
noms, de redéfinitions
† Syntaxe
†
†
Seulement pour le retour d’opérations
Mot clé void
IDL CORBA
Déclarer une interface revient à définir un type d’objet CORBA
(sous-type de Object)
Définir une interface revient à spécifier les points d’accès aux
objets CORBA de ce type
La définition d’une interface peut contenir la déclaration
d’opérations, d’attributs, d’exception, de types et de constantes
Peut être prédéclarée pour utilisation ultérieure
9
interface <id_interface> { <liste de déclarations> }
interface <id_interface_fille> : <id_interface_parent_1>
[,<id_interface_parent_2> ,...]
{…<liste de déclarations> }
IDL CORBA
© 2005-06 Th. Desprats
Les Opérations (1/2)
Les Opérations (2/2)
† Déclaration
† Retour
†
†
†
Uniquement à l’intérieur d’une définition d’interfaces
Une opération peut avoir des paramètres, retourner un résultat
et lever des exceptions, s’invoquer de façon synchrone ou non
Surcharge interdite
† Syntaxe
†
[oneway] //asynchrone si mentionné, synchrone par défaut
<type_IDL_retour> <identif.> (<liste_parametres>)
[raises (<liste_exceptions>)]
[context (<liste_des_contextes>)]
†
Remarques
„
„
„
IDL CORBA
†
Le <type_IDL_retour> peut être un type quelconque IDL pour les
opérations retournant un résultat, void pour les autres.
† Paramètres
„
Pour chaque paramètre, définir :
†
†
Son type : un type IDL quelconque
(de base, construit, indifférencié, objet CORBA (Object ou
interface déclarée))
Son mode d’utilisation :
„
Si l'opération est asynchrone : les paramètres sont alors
obligatoirement tous en entrée et le type de retour est
obligatoirement void;le client ne sait pas si l'opération est
réellement exécutée : la norme prévoit qu'elle le sera le mieux
possible et seulement une fois.
La <liste_exceptions> indique optionnellement les exceptions
pouvant être déclenchées par cette opération. Les identificateurs
des types d'exceptions sont séparés par des virgules. Une opération
en mode asynchrone (oneway) ne peut déclencher d'exception.
La <liste_des_contextes> permet de transmettre l'équivalent des
variables d'environnement depuis le client vers les objets.
© 2005-06 Th. Desprats
11
10
„
„
†
„
in (entrée) : le client fournit la valeur
si le serveur la modifie, le client ne perçoit pas la modification
inout (entrée/sortie) : le client fournit la valeur
si le serveur la modifie, le client perçoit la modification
out (sortie) : le serveur fournit la valeur
le client perçoit la modification
Son identificateur
Remarque
†
Passage de paramètres :
„
„
IDL CORBA
par référence pour les objets CORBA,
par valeur pour tous les autres types.
© 2005-06 Th. Desprats
12
3
Les Attributs
Les Exceptions
† Objectif
† Objectif
†
†
†
Déclarer un attribut revient à offrir au client un mécanisme
d’accès simple à une partie de l’état d’un objet (variables ou
propriétés)
Déclarer un attribut équivaut à déclarer deux opérations
(« Get » et « Set ») pour l’accès à une propriété.
Les attributs peuvent être consultés et modifiés par défaut, ou
seulement consultés si readonly est précisé (un seul accesseur).
† Syntaxe
†
[readonly] attribute <type_IDL> <identificateur>
†
interface compte {
readonly attribute string idcpte;
attribute float solde; };
est équivalent à :
† Syntaxe
†
†
interface compte {
string getId();
float getSolde();
void setSolde (in float s); } ;
IDL CORBA
© 2005-06 Th. Desprats
13
Les Modules
exception <identificateur>
{<type_IDL_champ_1> <id_champ1> ;
<type_IDL_champ_2> <id_champ2> ; …}
exception decouvert { string raison; long id; };
…
interface compte {
void debit (in float s) raises (decouvert); } ;
IDL CORBA
© 2005-06 Th. Desprats
14
Structure d’un fichier IDL
† Objectif
† Espace de définitions dans un fichier IDL :
permettent de structurer les applications
† Définitions de types, de constantes, d’exceptions,
d’interfaces… et de modules
† Hiérarchie possible
† Opérateur :: de résolution de portée
banque::compte::ccourant::debit
† Syntaxe
† module <identificateur>
{<liste de definitions> ;}
IDL CORBA
† Mécanisme qui permet de signaler à l'appelant un
problème d'exécution de l'opération. Une exception doit
être déclarée de façon analogue à une structure.
† Une exception « utilisateur » doit être obligatoirement
traitée au niveau du client.
† Existence d’exceptions « système » dans le module IDL
ORB CORBA (non obligatoirement traitées)
© 2005-06 Th. Desprats
15
//définition d'un groupe d'interfaces
module <nom>
{
<déclarations de types de données>
<déclarations de constantes> //e.g const pi = 3.14
<déclarations d'exceptions>
//définition d'un type d'objet
interface <nom_interface> [ :<interfaces héritées>]
{
<déclarations de types>
<déclarations de constante>
<déclarations d'attributs>
<déclarations d'exceptions>
//définition d'une opération
<type_opération> <nom_opération> ( <liste_paramètres> )
[raises (<exceptions>)][context]
…
//définition d'une opération
<type_opération> <nom_opération> ( <liste_paramètres> )
[raises (<exceptions>)][context]
}
//définition d'un type d'objet
interface <nom_interface> [ :<interfaces héritées>]
{
…
}
//fin du module
};
IDL CORBA
© 2005-06 Th. Desprats
16
4
Illustration
Exemple d’inclusion d’un autre fichier idl
Déclaration d’un module
attributs
attribut « en lecture »
méthodes
Méthode asynchrone
IDL CORBA
#includeunAutreFichier.idl
unAutreFichier.idl
#include
définition d’une exception
modulemonModule
monModule{ {
module
exception
monException{ {
exception monException
définition d’un nouveau
stringraison;
raison;
string
type de donnée
longid;id;
long
};};
définition d’une interface
typedefsequence<long>
sequence<long>vecteur;
vecteur;
typedef
interfacemonInterfaceDeBase
monInterfaceDeBase{…
{…};};
interface
monInterfaceDeBase{ {
interfacemonInterface
monInterface: :monInterfaceDeBase
interface
Exemple d’héritage d’interface
attributestring
stringunParametreAccessible;
unParametreAccessible;
attribute
readonlyattribute
attributelong
longunParametreInaccessible;
unParametreInaccessible;
readonly
stringuneMethode1
uneMethode1(in(instring
stringinParam,
inParam,out
outvecteur
vecteuroutParam);
outParam);
string
voiduneMethode2
uneMethode2(inout
(inout long
longinoutParam)
inoutParam)raises
raises(monException);
(monException);
void
oneway
uneMethodeAsynchrone(in
vecteur
unVecteur);
oneway uneMethodeAsynchrone(in vecteur unVecteur);
monInterface
};};////finfindedemonInterface
//findedemonModule
monModule
};};//fin
Mode de passage du
paramètre (in, out, inout)
déclaration
d’une exception
© 2005-06 Th. Desprats
17
5