PDF de programación - 3.2 Mapping de IDL a Java

3.2 Mapping de IDL a Java

Tipos predefinidos (1)

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

Tipo Java
short
int
long
short
int
long
float
double
De momento, no está soportado

n El rango de los tipos enteros IDL sin signo es mayor que el de los tipos

Java (los enteros sin signo grandes llegan como negativos)

Tipos predefinidos (y 2)

Tipo IDL
char
wchar
string
wstring
octet
boolean

any

Tipo Java
char
char
java.lang.String
java.lang.String
byte
boolean (las constantes IDL TRUE y
FALSE se mapean a true y false)
org.omg.CORBA.Any (abstracta)

n Se producen excepciones si se violan los rangos de los caracteres o el

tamaño de las cadenas de caracteres acotadas

typedef

n En Java no existe una construcción similar a

typedef

n Se usa el tipo original

Enumeraciones

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

// Java
public class Color

implements org.omg.CORBA.portable.IDLEntity {
public static final int _red = 0;
public static final Color red = new Color(_red);
public static final int _green = 1;
public static final Color green = new Color(_green);
// ...
public int value() { ... }
public static Color from_int(int value) { ... }
protected Color(int value) { ... }

}

n Dado que cada valor es un singleton, la igualdad entre valores se

puede comprobar con equals().

Estructuras

// IDL
struct Date {

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

};

// Java
final public class Date

implements org.omg.CORBA.portable.IDLEntity {
public short year;
public short month;
public short day;

public Date() {}
public Date(short year, short month,

short day) { ... }

}

Vectores y secuencias (1)

n Los vectores y secuencias (acotadas y no acotadas)

se mapean a vectores Java
n Se produce una excepción si se violan longitudes (vectores y

secuencias acotadas)

// IDL
typedef Date DateVector[10];
typedef string StringMatrix[10][20];
typedef sequence<Color> Colors;
typedef sequence<Date, 10> Dates10;

struct Example {

DateVector fDateVector;
StringMatrix fStringMatrix;
Colors fColors;
Dates10 fDates10;

};

Vectores y secuencias (y 2)

// Java
final public class Example

implements org.omg.CORBA.portable.IDLEntity {
public Date[] fDateVector;
public String[][] fStringMatrix;
public Color[] fColors;
public Date[] fDates10;

public Example() {}
public Example(Date[] fDateVector,

String[] fStringMatrix, Color[] fColors,
Date[] fDates10) { ... }

};

Módulos

n Se mapean a paquetes

n Los tipos definidos dentro del módulo que mapean a

clases/interfaces, pertenecerán al correspondiente paquete

// IDL
module es { module udc { module fbellas {

module corbaws { module clock { module idl {

struct TimeOfDay { ... };

}; }; }; }; }; };

// Java
package es.udc.fbellas.corbaws.clock.idl;
final public class TimeOfDay

implements org.omg.CORBA.portable.IDLEntity { ... }

Interfaces (1)

// IDL
interface Clock {

TimeOfDay getTimeOfDay();

};

// Java
public interface ClockOperations {

TimeOfDay getTimeOfDay();

} // Este tipo lo utiliza el servidor para implementar

// el interfaz

public interface Clock extends ClockOperations,

org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity {

} // Este tipo lo utiliza el cliente

Interfaces (2)

n También se generan las clases ClockPOA y

ClockPOATie
n Las utiliza el servidor para implementar el interfaz mediante

herencia de implementación (ClockPOA) o delegación
(ClockPOATie)

n Se estudian más adelante

n Object (IDL) se mapea a

org.omg.CORBA.Object (Java)

n nil (IDL) se mapea a null

n null sólo se puede usar en valores de retorno y

parámetros para representar una referencia a objeto remoto
o “tipo valor” (value type) nulos

n Cada atributo se mapea a dos operaciones con el

mismo nombre (una para leer y otra para modificar),
excepto si es de tipo readonly (sólo dispone de
operación para leer)

Interfaces (3)

n Herencia

// IDL
interface Thermostat : Thermometer { ... };

// Java
public interface ThermometerOperations { ... }
public interface Thermometer

extends ThermometerOperations,
org.omg.CORBA.Object,
org.omg.CORBA.portable.IDLEntity {}

public interface ThermostatOperations

extends ThermometerOperations { ... }

public interface Thermostat

extends ThermostatOperations,
Thermometer,
org.omg.CORBA.portable.IDLEntity {}

Interfaces (y 4)

n Tipos anidados dentro de interfaces

n Java no permite anidar clases dentro de interfaces
n Los tipos IDL (definidos dentro de una interfaz) que mapean

a clases se generan en un paquetes especial

// IDL
module Example {

interface Clock {

struct TimeOfDay { ... };
TimeOfDay getTimeOfDay();

};

};

// Java
package Example.ClockPackage;
final public class TimeOfDay

implements org.omg.CORBA.portable.IDLEntity { ... }

Constantes (1)

n Constantes definidas dentro de un interfaz

// IDL
module Example {

interface MyInterface {

const float PI = 3.1415926;

};

};

// Java
package Example;

public MyInterfaceOperations {}

public interface MyInterface extends MyInterfaceOperations,

org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity {
float PI = 3.1415926;

}

Constantes (y 2)

n Constantes definidas fuera de un interfaz
// IDL
module Example {

const float PI = 3.1415926;

};

// Java
package Example;

public interface PI {

float value = 3.1415926;

}

Excepciones (1)

Throwable

Error

Exception

RuntimeException

org.omg.CORBA

UserException

SystemException

Excepciones definidas
por el usuario en IDL

COMM_FAILURE, OBJ_ADAPTER,
etc.

Excepciones (y 2)

n Mapping de excepciones definidas por el usuario

// IDL
typedef short Temperature;
exception InvalidTemperature {

Temperature selectedTemperature;
Temperature minimumPermitedTemperature;
Temperature maximumPermitedTemperature;

};

// Java
final public class InvalidTemperature

extends org.omg.CORBA.UserException {

// Mapping similar al de un “struct”.

};

Clases Holder (1)

n Problema: mapear parámetros out e inout a Java

// IDL
interface Account {

void add(in float amount, out float newBalance);
// ...

};

n Paso de parámetros en Java

n Tipos básicos: por valor
n Objetos: “por referencia”
n Siendo más preciso: todos los parámetros se pasan

por valor (cuando se “pasan objetos”, se pasan
referencias por valor)

n La semántica de paso de parámetros vía out e

inout se simula con las clases Holder

Clases Holder (2)

n Mapping a Java

public interface AccountOperations {

void add(float amount,

org.omg.CORBA.FloatHolder newBalance);

// ...

}

n El ORB proporciona clases Holder para los tipos

predefinidos
package org.omg.CORBA;
final public class FloatHolder

implements org.omg.CORBA.portable.Streamable {
public float value;
public FloatHolder() {}
public FloatHolder(float value) { ... }
// Otros métodos ...

}

Clases Holder (3)

n Implementación de la operación

class AccountImpl extends AccountPOA {

private float balance;

public void add(float amount, FloatHolder newBalance) {

balance = balance + amount;
newBalance.value = balance;

}

// ...

}

n Invocación de la operación

FloatHolder newBalance = new newBalance();
account.add(10, newBalance);
System.out.println(newBalance.value);

Clases Holder (4)

n Para los tipos definidos por el usuario, el compilador

de IDL genera clases Holder
n Mismo nombre que el tipo Java pero con sufijo Holder

// IDL
struct TimeOfDay {

short hour; // 0-23
short minute; // 0-59
short second; // 0-59

};

interface Clock {

void getTimeOfDay(out TimeOfDay time);

};

n Para los tipos definidos con typedef, sólo se generan
clases Holder cuando se trata de vectores o secuencias

Clases Holder (5)

n El compilador de IDL genera la clase

TimeOfDayHolder
final public class TimeOfDayHolder

implements org.omg.CORBA.portable.Streamable {
public TimeOfDay value;
public TimeOfDayHolder() {}
public TimeOfDayHolder(TimeOfDay value) { ... }
// Otros métodos ...

}

n Implementación de la operación
class ClockImpl extends ClockPOA {

public void getTimeOfDay(TimeOfDayHolder time) {

<< Obtener “hour”, “minute” y “second” >>
TimeOfDay timeOfDay =

new TimeOfDay(hour, minute, second);

time.value = timeOfDay;

}
// ...

}

Clases Holder (y 6)

n Invocación de la operación

TimeOfDayHolder timeOfDayHolder = new TimeOfDayHolder();
clock.getTimeOfDay(timeOfDayHolder);
TimeOfDay timeOfDay = timeOfDayHolder.value;

n Parámetros inout

n Idem parámetros out, excepto:

n El llamador debe pasar un valor en el parámetro (excepto que

sirva el del constructor por defecto)

n El llamado puede consultar el valor (value) del Holder,

cambiarlo o establecer uno nuevo (holder.value = new
... )

Clases Helper (1)

n Concepto

n Para cada tipo definido por el usuario (inclusive los definidos

con typedef) se genera una clase Helper (mismo nombre
que el tipo Java pero con sufijo Helper)

n Permiten hacer downcasting de interfaces remotos
n Permiten insertar y extraer valores en un Any

n Ejemplo

abstract public class ClockHelper {

public static void insert(org.omg.CORBA.Any a,

Clock t) { ... }

public static Clock extract(org.omg.CORBA.Any) { ... }
public static org.omg.CORBA.TypeCode type() { ... }

// “narrow” sólo se genera para Helpers cuyo tipo es un
// interfaz remoto
public static Clock narrow(

org.omg.CORBA.Object obj) { ... }

}

Clases Helper (2)

n El downcasting es un casting de un tipo base (no
necesariamente org.omg.CORBA.Object) a un
tipo derivado
// En el ejemplo “Clock” ...
org.omg.CORBA.Object clockObject =

orb.string_to_object(stringifiedReference);

if (clockObject == null) {

throw new Exception("stringified reference is nil");

}
Clock clock = ClockHelper.narrow(clockObject);
n El objeto tiene que ser del tipo derivado (en otro caso se

produce una excepción del sistema CORBA)

n En el ejemplo anterior no sería válido hacer ...

Clock clock = (Clock)clockObject;

n ... porque puede ser necesario contactar con el servidor (ej.:

servidor configurado con arranque automático)

Clases