Download 3.2 Mapping de IDL a Java

3.2 Mapping de IDL a Java
Tipos predefinidos (1)
n
Tipo IDL
short
Tipo Java
short
long
int
long long
long
unsigned short
short
unsigned long
int
unsigned long long
float
long
double
double
long double
De momento, no está soportado
float
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)
n
Tipo IDL
char
Tipo Java
char
wchar
char
string
java.lang.String
wstring
java.lang.String
octet
byte
boolean
boolean (las constantes IDL TRUE y
FALSE se mapean a true y false)
any
org.omg.CORBA.Any (abstracta)
Se producen excepciones si se violan los rangos de los caracteres o el
tamaño de las cadenas de caracteres acotadas
typedef
n
n
En Java no existe una construcción similar a
typedef
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) { ... }
}
Union (1)
// IDL
union Token switch(Color) {
case blue:
float floatValue;
case red:
case green:
long longValue;
default:
string stringValue;
};
// Java
final public class Token
implements org.omg.CORBA.portable.IDLEntity {
public Token() { ... }
public Color discriminator() { ... }
Union (y 2)
public
public
public
public
public
float floatValue() { ... }
void floatValue(float value) { ... }
long longValue() { ... }
void longValue(long value) { ... }
void longValue(Color discriminator,
long value) { ... }
public String stringValue() { ... }
public void stringValue(String value) { ... }
public void stringValue(Color discriminator,
String value) { ... }
} // class
Vectores y secuencias (1)
n
Los vectores y secuencias (acotadas y no acotadas)
se mapean a vectores Java
Se produce una excepción si se violan longitudes (vectores y
secuencias acotadas)
// IDL
n
typedef
typedef
typedef
typedef
Date DateVector[10];
string StringMatrix[10][20];
sequence<Color> Colors;
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 corba { module clock { module idl {
struct TimeOfDay { ... };
}; }; }; }; }; };
// Java
package es.udc.fbellas.corba.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
n
n
n
Object (IDL) se mapea a
org.omg.CORBA.Object (Java)
nil (IDL) se mapea a null
n
n
Las utiliza el servidor para implementar el interfaz mediante
herencia de implementación (ClockPOA) o delegación
(ClockPOATie)
Se estudian más adelante
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
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
n
Java no permite anidar clases dentro de interfaces
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
n
n
n
Tipos básicos: por valor
Objetos: “por referencia”
Siendo más preciso: todos los parámetros se pasan
por valor (cuando se “pasan objetos”, se pasan
referencias por valor)
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
n
El llamador debe pasar un valor en el parámetro (excepto que
sirva el del constructor por defecto)
El llamado puede consultar el valor (value) del Holder,
cambiarlo o establecer uno nuevo (holder.value = new
... )
Clases Helper (1)
n
Concepto
n
n
n
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)
Permiten hacer downcasting de interfaces remotos
Permiten insertar y extraer valores en un Any
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
n
El objeto tiene que ser del tipo derivado (en otro caso se
produce una excepción del sistema CORBA)
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 Helper (y 3)
n
Inserción y extracción de valores en un Any
n
Inserción
RouterEvent routerEvent = ...
org.omg.CORBA.Any event =
orb.create_any(); // método factoría
RouterEventHelper.insert(any, routerEvent);
manager.sendEvent(event);
n
Extracción
public void sendEvent(org.omg.CORBA.Any event) {
RouterEvent routerEvent =
RouterEventHelper.extract(event);
// ...
}
n
n
Si el receptor no sabe cuál es el tipo contenido en el Any, puede
utilizar org.omg.CORBA.Any.type()
Any proporciona operaciones de inserción y extracción para los
tipos predefinidos (insert_float, extract_float, etc.)
Paquete org.omg
n
Todos los pseudo-interfaces del ORB y los interfaces
de los servicios estándares CORBA pertenecen a
subpaquetes de org.omg (ej.: org.omg.CORBA,
org.omg.CosNaming, etc.)