Objets IDL

Interfaces

PowerAMC représente les interfaces CORBA sous la forme de classes standard ayant le stéréotype <<CORBAInterface>> ou sous la forme d'interfaces standard (auxquelles un stéréotype <<CORBAInterface>> est automatiquement appliqué). Les propriétés d'interface IDL sont présentées comme suit :

Dans l'exemple suivant, le lien de composition indique qu'un attribut contenu dans TestInterface utilise l'autre interface TestStruct comme type de données. La déclaration dans l'interface est effectuée à l'aide d'un lien interne.

interface TestInterface {
 struct TestStruct {
  string member1;
 };

 attribute string StringA;
 attribute TestInterface::TestStruct MyStructAttr;
 void OperationA(inout TestStruct t, in string str);
 boolean OperationB(inout TestStruct t);
 
};

Modules

PowerAMC représente les modules CORBA sous la forme de packages ayant le stéréotype <<CORBAModule>>.

Un fichier IDL est généré pour chaque package. La hiérarchie de répertoires suit la hiérarchie de modules (et non la hiérarchie de packages) ce qui signifie que seuls les packages ayant comme stéréotype <<CORBAModule>> sont mis en correspondance avec les répertoires de fichiers. Les directives #include sont générées en fonction des dépendances ayant comme stéréotype <<include>> entre packages et en fonction des raccourcis vers les classes définis dans un package donné.

Data Types

PowerAMC représente les types de données CORBA sous la forme de classes ayant le stéréotype <<CORBAPrimitive>>, et les types de données fixes sous la forme de classes ayant le stéréotype <<CORBAFixed>>.

Lorsque vous appliquez le stéréotype <<CORBAFixed>>, les attributs étendus suivants sont automatiquement ajoutés à la classe, et vous devez leur spécifier des valeurs :

typedef fixed<8, 3> Class_1;

Constantes générales

PowerAMC représente les constantes générales CORBA (valeurs définies indépendamment de tout objet et qui sont appelées à être réutilisées) sous la forme d'attributs créés dans une classe, et la classe et les attributs portent les stéréotype <<CORBAConstants>>.

const char red = 13325;
const char blue = 14445;
const long green = 26664;

Constantes d'interface

PowerAMC représente les constantes d'interface CORBA (valeurs définies pour une interface spécifique) comme des attributs ayant le stéréotype <<CORBAConstants>>, qui sont créés dans l'interface dans laquelle ils seront utilisés.

interface screen {
 const short background = blue;
 const short fields = green

Définitions de type (Typedefs)

PowerAMC représente les définitions de type CORBA sous la forme de classes ayant le stéréotype <<CORBATypedef>>. La classe typedef doit être liée à une classe ayant le stéréotype <<CORBAPrimitive>>, <<CORBAStruct>> ou <<CORBAUnion>> via un lien de généralisation pour définir le type des données.

typedef num identifier;

Séquences, séquences anonymes et séquences dans une structure

PowerAMC représente les séquences CORBA sous la forme de classes ayant le stéréotype <<CORBASequence>>. La limite supérieure de la séquence est spécifié par son attribut étendu UpperBound, et son type est défini dans une autre classe qui lui est liée par une association.

typedef sequence< string > name_lastname;

Pour éviter de définir directement un type de séquence afin de concevoir une imbrication de séquence, utilisez le stéréotype <<CORBAAnonymousSequence>>.

typedef sequence< sequence< string > > Election_list;

Pour créer une séquence dans un structure, appliquez le stéréotype <<CORBAAnonymousSequence>> à la classe de séquence.

struct Customer {
 string name_lastname;
 long age;
 sequence< string > w;
};

Types de valeurs (valuetypes) et types de valeurs personnalisés

PowerAMC représente les types de valeurs CORBA sous la forme de classes ayant le stéréotype <<CORBAValue>> et les types de valeurs personnalisés sous la forme de classes ayant le stéréotype <<CORBACustomValue>>. Vous pouvez enrichir la définition du type de valeur comme suit :

valuetype DateAndTime : Time supports PrettyPrint {
 public DateAndTime::Date the date;
 factory init(in short hr, in short min);
 string get_date();
 
};

Valeurs encadrées (boxed values)

PowerAMC représente les valeurs encadrées CORBA sous la forme de classes ayant le stéréotype <<CORBABoxedValue>>. La valeur encadrée ne prenant pas en charge l'héritage ni les opérations, vous devez donc utiliser une classe ayant le stéréotype <<CORBAAnonymousSequence>> pour l'associer à une valeur encadrée avec une interface.

valuetype OptionalNameSeq sequence< myName >;

Enuméations (enums)

PowerAMC représente les énumérations CORBA sous la forme de classes ayant le stéréotype <<CORBAEnum>>, et les éléments d'énumération sous la forme d'attributs ayant le stéréotype <<CORBAEnum>>.

Structures (structs)

PowerAMC représente les types de structure CORBA sous la forme de classes ayant le stéréotype <<CORBAStruct>>. Vous pouvez mélanger les types d'attribut dans la classe struct.

struct Customer {
 string name_lastname;
 long age;
};

Vous utilisez des liens de composition pour définir des classes struct complexes comme défini dans l'exemple suivant :

struct Customer {
 string name_lastname;
 long age;
 Address references;
 Customer_Category belongs;
};

Pour définir une structure au sein d'une autre structure, créez deux classes avec le stéréotype <<CORBAStruct>> ajoutez une composition entre les classes et utilisez la fonctionnalité lien interne pour déclarer une classe comme étant interne à l'autre classe.

struct A {
 struct B {
  short c;
  long d;
 } e, z;
 string x;
};

Unions

PowerAMC représente les unions CORBA sous la forme de classes ayant le stéréotype <<CORBAUnion>>. Chaque attribut d'union représente un cas (case), l'attribut étendu Case (Profile\Attribute\Criteria\IDL union member\Extended Attributes) contient la valeur par défaut de cas.

Pour définir le type de données switch le type de données discriminant pour les cas d'union, vous devez ajouter un attribut nommé <nom classe>_switch dans la liste des attributs d'union.

union Test switch(char) {
 case 1:
  char Test1;
 case 2:
  string Test2;
 default:
  short Test3;
};

Vous pouvez utiliser une énumération ou une structure dans une union à l'aide d'une association de composition.

union Customer switch(short) {
 case XYZ:
  char Last_Name;
 case ZYX:
  char Name;
 default:
  Identification uses;
};

Le nom de l'attribut se trouve sur le rôle d'association et le cas se trouve sur l'association.

Vous pouvez utiliser une énumération ou une structure comme type de données switch en utilisant une association de composition. Dans ce cas de figure, le rôle de la composition est utilisé comme attribut switch pour l'union.

union Screen switch(Colors) {
 case red:
  short background;
 case blue:
  short foreground;
};

Si vous n'utilisez pas le rôle de composition comme attribut switch, vous devez tout de même définir un attribut switch dans l'Union.

Tableaux (arrays)

PowerAMC représente les tableaux CORBA sous la forme de classes ayant le stéréotype <<CORBAArray>>. Vous devez lier la classe de tableau avec une autre classe représentant le type de tableau (utilisez le stéréotype <<CORBAPrimitive>> pour définir ce type), et définir la dimension du tableau dans l'attribut étendu Dims de la classe de tableau (une liste des dimensions séparées par des virgules (entiers) pour le tableau). Elle est utilisée à la place des qualificateurs index<i> sur l'extrémité d'association (associationEnd) spécifiée dans le profil CORBA.

Dans l'exemple suivant, le tableau 2D_array utilise un type de données de chaîne défini à 10 :

typedef string 2D_array[10];

Vous pouvez utiliser une classe ayant le stéréotype <<CORBAAnonymousSequence>> pour éviter d'avoir à définir directement un type pour un tableau de séquence.

typedef sequence< string > 2D_array[10];

Pour définir des tableaux pour un attribut d'union ou de structure, vous devez utiliser les propriétés de multiplicité de l'attribut.

union Customer switch(short) {
 case XYZ:
  char Last_Name[30];
 case ZYX:
  char Name[20];
};

Vous pouvez également utiliser la multiplicité d'association lorsque l'union ou la structure est liée à une autre classe. Le rôle et la multiplicité d'association deviennent des attributs de tableau des classes union ou struct :

struct Client {
 char Name[30];
 short Age[3];
 European_Client European attributes[5];
};

Exceptions

PowerAMC représente les exceptions CORBA sous la forme de classes ayant le stéréotype <<CORBAException>>, en déclarant la classe comme interne à l'interface qui risque de provoquer l'exception.

Cette liste d'exceptions est définie dans l'onglet Exceptions de l'onglet Mise en oeuvre d'une feuille de propriétés d'opération, et n'est pas placée entre parenthèses.

interface TEX {
 exception Badness2000 {
  string err_msg;
 };

 void process_token(in string tok) raises (Badness2000);
 
};

struct AdminLimit {
 PropertyName name;
 PropertyValue value;
};

exception AdminLimitExceeded {
 AdminLimit admin_property_error;
};