PDF de programación - 3.1 El lenguaje de especificación IDL

3.1 El lenguaje de especificación IDL

El lenguaje de especificación IDL

n Permite especificar interfaces remotas en un

lenguaje neutral

n El compilador (preprocesador) de IDL genera código
para el lenguaje(s) destino(s) (para poder invocar las
operaciones e implementar las interfaces)

n Mappings estandarizados para un buen número de

lenguajes (C, C++, Java, COBOL, Smalltalk, Ada,
etc.)
n Cada vez se van añadiendo más ...

n Actualmente IDL es un lenguaje relativamente

extenso
n Veremos lo esencial ...

Reglas léxicas (1)

n Ficheros fuente IDL

n Deben tener la extensión .idl
n Son preprocesados por el preprocesador de C++

n Se puede usar #define, #include, #ifdef, #ifndef,

#endif, etc.

n Comentarios

// Esto es un comentario de una línea.

/* Esto es un comentario

de varias líneas. */

n Palabras reservadas

n Casi todas en minúsculas
n Algunas excepciones: TRUE, FALSE y Object

Reglas léxicas (y 2)

n Identificadores

n Deben comenzar con un carácter alfabético seguido por
cualquier número de caracteres alfabéticos, dígitos o “_”
(subrayado)

n No se distingue entre mayúsculas y minúsculas, pero deben

utilizarse consistentemente

n Si definimos el identificador MAX, a partir de ese momento

siempre debemos utilizar MAX y no Max, max, etc.

n Objetivo: permitir mappings de IDL tanto a lenguajes que

distinguen entre mayúsculas y minúsculas en identificadores
(ej.: C++, Java) como a otros que no (ej.: Ada)

n Es importante evitar nombres de identificadores que sean

palabras reservadas en algún de lenguaje de
implementación (ej.: package, self)

Tipos predefinidos (1)

n Numéricos

Tipo
short
long
long long
unsigned short
unsigned long
unsigned long long
float
double
long double

Rango
-215.. 215-1
-231.. 231-1
-263.. 263-1
0.. 216-1
0.. 232-1
0.. 264-1
IEEE Precisión simple
IEEE Precisión doble
IEEE Precisión extendida

Tamaño
>= 16 bits
>= 32 bits
>= 64 bits
>= 16 bits
>= 32 bits
>= 64 bits
>= 32 bits
>= 64 bits
>= 79 bits

Tipos predefinidos (2)

n Numéricos (cont)

n El mapping de IDL a un lenguaje de implementación debe

preservar el tamaño, pero no necesita mantener el rango

n ¿ Por qué los tamaños pueden ser mayores ?

n Ej.: algunas arquitecturas (CPUs) no disponen de caracteres de

8 bits o enteros de 16 bits, y se mapean a tipos con tamaños
mayores

n ¿ Por qué algunos mappings no mantienen los rangos

n Ej.: Java no tiene enteros sin signo, y por tanto, mapea los

tipos IDL long y unsigned long al tipo Java int

n long long, unsigned long long, long double se

añadieron en CORBA 2.1, por lo que los ORBs
antiguos no los soportarán

Tipos predefinidos (3)

n Caracteres

n char: 8 bits
n wchar: tamaño dependiente de la implementación
n Codificación: dependiente de la implementación en ambos casos,

pero el ORB se preocupará de realizar la conversión (si puede)
cuando cliente y servidor utilizan distintos sistemas de codificación

n Cadenas de caracteres

n string y wstring. No pueden contener carácter 0
n Ejemplos

string<10> // string acotado (10 char como máximo)
string // string no acotado
wstring<10> // wstring acotado (10 wchar como máximo)
wstring // wstring no acotado

n string<x> y wstring<x> son tipos propios (distintos de

string y wstring)

n wchar y wstring se añadieron en CORBA 2.1, por lo que

los ORBs antiguos no los soportarán

Tipos predefinidos (y 4)

n octet
n 8 bits
n No se realiza ninguna conversión entre cliente y servidor
n Utilidad: transferir datos binarios

n boolean

n Proporciona los valores TRUE y FALSE

n any

n En un tipo “contenedor”: un valor de tipo “any” puede

contener un valor de cualquier tipo (predefinido o definido
por el usuario)

n Es seguro (type-safe) y permite instrospección
n Utilidad: cuando en una operación no se conoce el tipo de

uno de sus parámetros en tiempo de compilación (ej.:
servicio de eventos)

typedef

n Permiten crear un nuevo nombre para un tipo

typedef short Year;
typedef short Temperature;
typdef Temperature Temp; // ¡ Mal estilo !

n Permiten realizar especificaciones más claras
n Se deben evitar alias innecesarios (ej.: la tercera

definición)
n Es confuso
n Puede causar problemas en los mappings que utilicen reglas

estrictas de equivalencia de tipos

Enumeraciones

n Ejemplo

enum Color {red, green, blue, yellow, white};

n A diferencia de C, Color es un tipo y el nombre del

tipo es obligatorio
typedef enum {red, green, blue} Color; // ¡ Error !

n Los valores de un tipo deben ser únicos dentro de su

ámbito
enum InteriorColor {red, green, blue};
enum ExteriorColor {blue, yellow, white}; // ¡ Error !
n A diferencia de C++, no se les puede dar valores
enum Color {red=0, green=8, blue=16}; // ¡ Error !

Estructuras

n Ejemplo

struct Date {

short year;
short month; // 1-12
short day; // 1-31

};

n A diferencia de C, Date es un tipo y el nombre del

tipo es obligatorio
typedef struct {

short year;
short month; // 1-12
short day; // 1-31
} Date; // ¡ Error !

Vectores

n Se pueden definir vectores de una o varias

dimensiones
typedef Date DateVector[10]; // Tipo “DateVector”
typedef string StringMatrix[10][20]; // Tipo “StringMatrix”

n Se debe usar typedef
n A diferencia de otros lenguajes, no soporta vectores

abiertos (“open arrays”)
typedef string StringMatrix[][20]; // ¡ Error !

n Hay que tener cuidado cuando se pasan índices de

arrays en invocaciones remotas
n Es preciso definir una convención

Secuencias

n Las secuencias son vectores de longitud variable

typedef sequence<Color> Colors; // Secuencia no acotada
typedef sequence<Date, 10> Dates10; // Secuencia

// acotada (10 fechas como máximo)

n Se debe usar typedef
n ¿ Cuándo usar secuencias y cuándo usar vectores ?
n Una lista de cosas con número fijo de elementos => vector
n Una lista de cosas con número variable de elementos =>

secuencia

n Cadenas de caracteres de tamaño fijo => vector de char
n Vectores dispersos (“sparse arrays”) => secuencias
n Estructuras de datos recursivas => secuencias

Tipos de datos recursivos

n IDL no tiene punteros, pero permite definir

estructuras recursivas
struct Node {

long value;
sequence<Node, 2> children;

}; // Un árbol binario

n Restricciones

n Sólo para struct
n La recursividad se expresa con una secuencia anónima del

tipo incompleto (recursivo)

n No se permite recursividad mutua

Constantes y literales

n Se pueden definir de cualquier tipo predefinido

(excepto any) o de un enumerado
const short MAX_TEMP = 35;
const short MIN_TEMP = -10;
const short AVG_TEMP = (MAX_TEMP+MIN_TEMP)/2;
const float PI = 3.1415926;
const double MAXIMUM = 1E10;
const char FIRST_LOWER_CASE_LETTER = ‘a’;
const char NULL = ‘\0’;
const string LAST_WORDS = “My God, it’s full of stars !”;
const octet MSB_MASK = 0x10; // Hexadecimal (tb. en enteros)
const octet MSB_MASK2 = 0100; // Octal (tb. en enteros)
const Color FAVORITE_COLOR = blue;

n Las expresiones pueden utilizar

n +, -, *, /, % (con enteros y reales, excepto %)
n |, &, ^, <<, >>, ~ (con enteros)

Interfaces (1)

n Ejemplo

interface Thermostat {

typedef short Temperature;
typedef string Location;
exception InvalidTemperature {

Temperature selectedTemperature;
Temperature minimumPermitedTemperature;
Temperature maximumPermitedTemperature;

};

Tempeature getTemperature();
void setTemperature(in Temperature value)

raises(InvalidTemperature)

Location getLocation();

};

Interfaces (y 2)

n Un interfaz es un tipo

interface Controller {

typedef sequence<Thermostat> ThermostatList;

ThermostatList findAllThermostats();
Thermostat findThermostatByLocation(

in Thermoter::Location loc);

};

n Los objetos remotos se pasan por referencia

n En el anterior ejemplo, el cliente obtiene una referencia a un

proxy del objeto remoto. ¡¡¡ Los objetos remotos no se
mueven !!!

n Existe la referencia especial “nil”

n Utilidad: indicar opcionalidad (pasar “nil” en un parámetro que

admita un objeto remoto) o indicar “no encontrado”
(findThermostatByLocation)

Operaciones (1)

n Pueden devolver excepciones
n No se pueden sobrecargar
n Atributos direccionales

n in: el valor del parámetro se lo envía el cliente al servidor
n out: el valor del parámetro se lo envía el servidor al cliente
n inout: el valor del parámetro se lo envía el cliente al

servidor, quien posiblemente lo modifica, y se lo envía otra
vez al cliente (machacando el valor anterior)

n Estilo

n Si una operación acepta uno o más parámetros in y

devuelve un solo resultado => el resultado se debería
devolver como valor de retorno

n Si una operación tiene varios valores de retorno con la

misma importancia => usar out para los correspondientes
parámetros y void como tipo de retorno

Operaciones (y 2)

n Estilo

n Si una operación retorna varios valores, pero uno de ellos
tiene más importancia => devolver este último como valor
de retorno y el resto como out
boolean getNext(out ValueType value);

n Usar los parámetros inout con precaución

n Se asume que el llamador no quiere conservar el valor
n Eficientes cuando se pasan valores grandes
n Ejemplo

invertMatrix (inout Matrix aMatrix);

Excepciones definidas por el usuario (1)

n Ejemplo

exception InvalidTemperature {

Temperature selectedTemperature;
Temperature minimumPermitedTemperature;
Temperature maximumPermitedTemperature;

};

n Pueden no tener campos
n No admiten herencia

n Complicaría algunos mappings

n No se pueden usar como campos de tipos definidos

por el usuario

n Si una operación puede levantar varias excepciones,

se separan por comas en la cláusula raises
void foo() raises(Exception1, Exception2);

Excepciones definidas por el usuario (2)

n Mal estilo

interface DataBase {

typedef sequence<Row> RowList;
typedef string Query;

exception NoRow {

Query failedQuery;

};

RowList lookup(in Query q) raises(NoRow);

};
n Puede ser normal que no exista ningún registro que cumpla

la query

n El campo failedQuery no aporta nada
n ¿ Por qué falló la query ?

n ¿ no había filas que c