✒️ABAP POO Los Eventos

EVENTOS:

Disparar y Manejar eventos: (TRIGGERS Y HANDLERS)

En ABAP Objects hay ciertos métodos que se conocen como disparadores (triggers) y otros que se conocen como manejadores (handlers). Los triggers son los métodos que disparan un evento, mientras que los handlers son los métodos que se ejecutan cuando ocurre un evento.

Eventos disparadores

Para disparar un evento una clase tiene que:

− declarar el evento en la parte declarativa

− disparar el evento en uno de sus métodos.

Declaración de eventos

Los eventos se declaran en la parte declarativa de una clase o en una interface.

Para declarar eventos dependientes de instancia se usa la sentencia:

EVENTS <evt> EXPORTING... VALUE(<ei>) TYPE type [OPTIONAL]..

Para declarar eventos estáticos se usa la sentencia:

CLASS-EVENTS <evt>...

Ambas sentencias tienen la misma sintaxis. Cuando se declara un evento se puede usar la adición EXPORTING para especificar parámetros que se pasan al manejador del evento. Los parámetros se pasan siempre por valor. Los eventos dependientes de instancia siempre contienen el parámetro implícito SENDER, el cual tiene el tipo de una referencia al tipo o a la interface en la cual el evento es declarado.

Disparar eventos

Un evento dependiente de instancia en una clase puede ser disparado por cualquier método en la clase. Los eventos estáticos son disparados por métodos estáticos. Para disparar un evento en un método se usa la siguiente sentencia:

RAISE EVENT <evt> EXPORTING... <ei> = <f i>...

Por cada parámetro formal <ei> que no esté definido como opcional se tiene que pasar el correspondiente parámetro real <f i> en la adición EXPORTING. La referencia a sí mismo ME es pasada automáticamente al parámetro implícito SENDER.

Eventos manejadores

Los eventos se usan para ejecutar una serie de métodos. Estos métodos tienen que:

− estar definidos como eventos manejadores (handler) de ese evento

− estar registrados en tiempo de ejecución para el evento.

Declaración de métodos manejadores de eventos

Una clase puede contener métodos manejadores de eventos para eventos tanto de su propia clase como de otras clases. Para declarar un método manejador de eventos dependiente de instancia se usa la siguiente sentencia:

METHODS <meth> FOR EVENT <evt> OF <cif> IMPORTING.. <ei>..

Para métodos estáticos se usa la misma sentencia con CLASS-METHODS en vez de METHODS. <evt> es un evento declarado en la clase o en la interface <cif>.

La interface de un método manejador de eventos sólo puede contener parámetros formales definidos en la declaración del evento. Los atributos de los parámetros también son adoptados por el evento. El método manejador de eventos no tiene por que usar todos los parámetros pasados en la sentencia RAISE EVENT. Si se quiere usar también el parámetro implícito SENDER, se tiene que listar en la interface. Este parámetro permite al manejador dependiente de instancia acceder al disparador para por ejemplo permitir devolver resultados. Si se declara un método manejador de eventos en una clase quiere decir que las instancias de la clase o la misma clase va a ser en principio capaz de manejar un evento disparado en un método.

Registro de métodos manejadores de eventos

Para permitir a un método manejador de eventos reaccionar a un evento, se tiene que determiar en tiempo de ejecución el disparador al cual va a reaccionar. Esto se hace con la siguiente sentencia:

SET HANDLER... <hi>... [FOR]...

Esta sentencia relaciona los métodos manejadores de eventos con sus correspondientes métodos.

Hay cuatro tipos diferentes de eventos:

− Eventos dependientes de instancia declarados en una clase.

− Eventos dependientes de instancia declarados en una interface.

− Eventos estáticos declarados en una clase.

− Eventos estáticos declarados en una interface.

La sintaxis y el efecto de la sentencia SET HANDLER depende de cual de los cuatro casos de arriba tenga lugar.

Para un evento dependiente de instancia se tiene que usar la adición FOR para especificar la instancia para la cual se quiere registrar el manejador. Se puede especificar una sola instancia como disparador usando una variable referenciada <ref>:

SET HANDLER... <hi>...FOR <ref>.

o se puede registrar el manejador para todas las instancias que puedan disparar el evento:

SET HANDLER... <hi>...FOR ALL INSTANCES.

En este caso el registro se aplica incluso a las instancias que aún no han sido creadas cuando se registra el manejador.

No se puede usar la adición FOR para los eventos estáticos:

SET HANDLER... <hi>...

El registro se aplica automáticamente a la clase entera o a todas las clases que implementan la interface que contiene el evento estático. En el caso de las interfaces, el registro también se aplica a las clases que aún no han sido cargadas cuando el manejador se registra.

Coordinación en el manejo de eventos

Después de la sentencia RAISE EVENT, todos los métodos manejadores registrados son ejecutados antes de que la siguiente sentencia sea procesada (manejo de eventos sincrónico). Si un método manejador de eventos desencadena eventos, los correspondientes métodos manejadores de eventos son ejecutados antes de que el método manejador original continue. Para evitar la posibilidad de un bucle infinito, actualmente los eventos sólo se pueden anidar 64 niveles.

Los métodos manejadores de eventos son ejecutados en el orden en el que son registrados. Debido a que los manejadores de eventos son registrados dinámicamente, no se puede saber el orden en el que serán procesados. Por esto se deben programar todos los manejadores de eventos como si se fuesen a ejecutar todos simultáneamente.

EJEMPLO DE EVENTOS:

El siguiente ejemplo muestra cómo se trabaja con eventos en ABAP Objects:

REPORT demo_class_counter_event.

*******************************************************************

CLASS counter DEFINITION.

PUBLIC SECTION.

METHODS increment_counter.

EVENTS critical_value EXPORTING value(excess) TYPE i.

PRIVATE SECTION.

DATA: count TYPE i,

threshold TYPE i VALUE 10.

ENDCLASS.

*******************************************************************

CLASS counter IMPLEMENTATION.

METHOD increment_counter.

DATA diff TYPE i.

ADD 1 TO count.

IF count > threshold.

diff = count - threshold.

RAISE EVENT critical_value EXPORTING excess = diff.

ENDIF.

ENDMETHOD.

ENDCLASS.

*******************************************************************

CLASS handler DEFINITION.

PUBLIC SECTION.

METHODS handle_excess

FOR EVENT critical_value OF counter

IMPORTING excess.

ENDCLASS.

*******************************************************************

CLASS handler IMPLEMENTATION.

CLASS handler IMPLEMENTATION.

METHOD handle_excess.

WRITE: / 'Excess is', excess.

ENDMETHOD.

ENDCLASS.

*******************************************************************

DATA: r1 TYPE REF TO counter,

h1 TYPE REF TO handler.

START-OF-SELECTION.

CREATE OBJECT: r1, h1.

SET HANDLER h1->handle_excess FOR ALL INSTANCES.

DO 20 TIMES.

CALL METHOD r1->increment_counter.

ENDDO.

La clase counter implementa un contador. Se desencadena el evento critical_value cuando el valor umbral (threshold) es excedido, y se visualiza la diferencia. La clase handler puede manejar las excepciones en la clase counter. El manejador es registrado en tiempo de ejecución para todas las variables referenciadas que apunten al objeto.

El siguiente ejemplo muestra cómo declarar, llamar y manejar eventos en ABAP Objects. Este objeto trabaja con la lista interactiva desplegada debajo. Cada interacción del usuario desencadena un evento en ABAP Objects. La lista y sus datos son creados en la clase c_list. Hay una clase status para procesar las acciones del usuario. Se desencadena el evento button_clicked en el evento at usercommand.

El evento es manejado en la clase c_list. Hay un objeto de la clase c_ship o c_truck para cada linea de la lista. Ambas clases implementan la interface i_vehicle. Cuando la velocidad de cualquiera de los objetos cambia, el evento speed_change es desencadenado. La clase c_list reacciona a esto actualiza la lista.