Befehlsverkettung – Don’t try this at home!

Den CL_SALV_TABLE kann man leider nicht „elegant“ erzeugen. Darunter verstehe ich, dass man die SALV-Referenz per RECEIVING bekommt. Sobald ein Exporting- oder Changing-Parameter in der Methode verwendet wird, kann RETURNING nicht mehr benutzt werden.

Der Aufruf ist zwar kompakt:

CALL METHOD cl_salv_table=>factory
 EXPORTING
 r_container = gr_dock
 IMPORTING
 r_salv_table = gr_salv
 CHANGING
 t_table = gt_data.
gr_salv->display( ).

aber man kann ihn nicht wie folgt verwenden:

cl_salv_table=>factory( ... )->display( ).

Ich wollte nun wissen, ob man die Erzeugung eines SALV-Tables plus Anzeige trotzdem in einen funktionalen Aufruf schreiben kann. Geklappt hat es zwar, jedoch wiederum mit einem Nachteil.

Befehlsverkettung

Methoden von durch RETURNING übergebenen Objektreferenzen können direkt durch Befehlsverkettung ausgeführt werden.

Dazu ein kleines Testprogramm mit einer FACTORY-Methode:

*----------------------------------------------------------------------*
* CLASS lcl_test DEFINITION
*----------------------------------------------------------------------*
CLASS lcl_test DEFINITION.
 PUBLIC SECTION.
 CLASS-METHODS factory RETURNING value(object) TYPE REF TO lcl_test.
 METHODS show.
ENDCLASS. "lcl_salv DEFINITION

*----------------------------------------------------------------------*
* CLASS lcl_salv IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lcl_test IMPLEMENTATION.
 METHOD factory.
 CREATE OBJECT object.
 ENDMETHOD. "factory

 METHOD show.
 MESSAGE 'Hallo' TYPE 'I'.
 ENDMETHOD. "show

ENDCLASS. "lcl_test IMPLEMENTATION

Normalerweise würde man die Methode SHOW folgendermaßen aufrufen:

DATA lr_test TYPE REF TO lcl_test.
lr_test = lcl_test=>factory( ).
lr_test->show( ).

Durch Verwendung einer Befehlsverkettung kann der Aufruf wie folgt aussehen:

lcl_test=>factory( )->show( ).

In diesem Umfang ist die Befehlsverkettung auch vertretbar. Sie kann jedoch Auswüchse annehmen, die ich nicht mehr warten möchte…

CL_SALV_TABLE

Zurück zum meinem eigentlich Problem: Die Anzeige des SALV-Grid mit einem Aufruf. Hindernis dabei ist, dass die SALV-Referenz eben nicht per RETURNING zurück gegeben wird, sondern als IMPORTING-Parameter.

Ich schrieb also ein kleines Wrapper-Programm. Ich habe die Übergabe der einzelnen Parameter in einzelne Methoden ausgelagert um diese nacheinander „funktional“ aufrufen zu können. Dafür muss die eigene Instanz jeweils an den Aufrufer übergeben werden.

Auch dabei musste ich tricksen, denn die anzuzeigende Tabelle kann nicht als CHANGING übergeben werden. Ich musste deswegen mit einer Referenz auf die Tabelle arbeiten.

 DATA gd_table TYPE REF TO data.
 GET REFERENCE OF gt_data INTO gd_table.

Dadurch erreiche ich natürlich nicht das, was ich eigentlich wollte, nämlich einen kompakten Methodenaufruf. Immerhin: Der Aufruf sieht nun wirklich interessant aus:

lcl_salv=>factory( )->set_table( gd_table )->create_grid( )->display( ).

DISPLAY ist hierbei bereits die Methode des SALV-Table, die durch CREATE_GRID erzeugt wird!

Sicherlich nicht elegant, aber es lässt sich gut demonstrieren, wie die funktionalen Aufrufe funktionieren.

Diese Methode ist selbstverständlich nur dann sinnvoll, wenn man sicher ist, dass man das SALV-Objekt nicht mehr benötigt, denn bei diesem Aufruf erzeugt man das Objekt, benutzt es, aber die Referenz darauf ist sofort wieder weg.

Code

*----------------------------------------------------------------------*
* CLASS lcl_salv DEFINITION
*----------------------------------------------------------------------*
CLASS lcl_salv DEFINITION.
 PUBLIC SECTION.
 DATA mt_table TYPE REF TO data.
 CLASS-METHODS factory RETURNING value(object) TYPE REF TO lcl_salv.
 METHODS create_grid RETURNING value(salv) TYPE REF TO cl_salv_table.
 METHODS set_table IMPORTING table TYPE REF TO data
 RETURNING value(object) TYPE REF TO lcl_salv.
ENDCLASS. "lcl_salv DEFINITION

*----------------------------------------------------------------------*
* CLASS lcl_salv IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lcl_salv IMPLEMENTATION.
 METHOD factory.
 create object object.
 ENDMETHOD. "factory

 METHOD create_grid.

 FIELD-SYMBOLS <table> TYPE ANY TABLE.
 ASSIGN mt_table->* TO <table>.

 CALL METHOD cl_salv_table=>factory
 IMPORTING
 r_salv_table = salv
 CHANGING
 t_table = <table>.

 ENDMETHOD. "factory

 METHOD set_table.
 mt_table = table.
 object = me.
 ENDMETHOD. "set_table
ENDCLASS. "lcl_salv IMPLEMENTATION
image_pdfimage_print
Enno Wulff
follow me
Letzte Artikel von Enno Wulff (Alle anzeigen)