Java-Wrapperklassen

Wenn Sie für einen Programmabschnitt eine Generierung als Java™-Wrapper anfordern, erstellt EGL jeweils eine Wrapperklasse für die folgenden Komponenten:

Die Wrapperklassen für ein bestimmtes Programm werden im Folgenden auch als Programmwrapperklassen, Parameterwrapperklassen, Wrapperklassen für dynamische Feldgruppen und Wrapperklassen für Feldgruppen mit unterstrukturierten Feldern bezeichnet.

EGL generiert eine Klasse 'BeanInfo' für die einzelnen Parameterwrapperklassen, Wrapperklassen für dynamische Feldgruppen und Wrapperklassen für Feldgruppen mit unterstrukturierten Feldern. Die Klasse 'BeanInfo' ermöglicht die Verwendung der zugehörigen Wrapperklassen als Java-kompatible Java-Bean. Sie werden wahrscheinlich nicht mit der Klasse 'BeanInfo' interagieren.

Wenn Sie einen Wrapper generieren, darf die Parameterliste des aufgerufenen Programms keine Parameter des Typs BLOB, CLOB, Dictionary oder ArrayDictionary und keine nicht strukturierten Datensätze enthalten.

Übersicht über die Verwendung der Wrapperklassen

Sie können Wrapperklassen für die Kommunikation mit einem Programm verwenden, das mit VisualAge Generator oder EGL generiert wurde, indem Sie im nativen Java-Programm wie folgt vorgehen:
  • Erstellen Sie bei Bedarf eine Klasse des Typs 'PowerServer' oder 'SharedResourcePowerServer', um Middleware-Service wie das Konvertieren von Daten zwischen nativem Java-Code und einem generierten Programm bereitzustellen:
    import com.ibm.javart.JavartException;
    import com.ibm.javart.calls.*;
    
    
      public class MyNativeClass 
      {
        /* declare a variable for middleware */
        PowerServer powerServer = null;
        powerServer = new PowerServerImpl();
      }

    Die von einem SharedResourcePowerServer-Objekt bereitgestellte Funktionalität ist umfassender als die eines PowerServer-Objekts. Nähere Angaben zu SharedResourcePowerServer-Objekten finden Sie im Abschnitt 'SharedResourcePowerServer'.

    Wenn Sie kein PowerServer-Objekt angeben, stellt die EGL-Laufzeitumgebung ein PowerServer-Objekt für Sie bereit.

  • Erstellen Sie wie folgt eine Instanz einer Programmwrapperklasse:
    • Ordnen Sie Datenstrukturen, einschließlich dynamischer Feldgruppen (soweit vorhanden), zu.
    • Ermöglichen Sie den Zugriff auf Methoden, die wiederum auf das generierte Programme zugreifen.
    Der Aufruf an den Konstruktor kann ein Middleware-Objekt einbeziehen:
      // Die Verwendung eines PowerServer-Objekts ist optional.
      myProgram = new MyprogramWrapper(PowerServer); 

    Sie können ein PowerServer-Objekt bereitstellen, wenn Sie das Wrapperobjekt aufrufen. Sie können es auch bereitstellen, indem Sie die Wrapperobjektmethode 'setPowerServer' aufrufen.

  • Deklarieren Sie Variablen, die auf den Parameterwrapperklassen basieren:
      Mypart  myParm = myProgram.getMyParm();
      Mypart2 myParm2 = myProgram.getMyParm2(); 
    Deklarieren Sie zusätzliche Variablen, die jeweils auf einer Wrapperklasse für dynamische Feldgruppen basieren, wenn Ihr Programm über Parameter verfügt, bei denen es sich um dynamische Feldgruppen handelt:
      myRecArrayVar myParm3 = myProgram.getMyParm3();

    Nähere Angaben zur Interaktion mit dynamischen Feldgruppen finden Sie in Wrapperklassen für dynamische Feldgruppen.

  • Verwenden Sie in den meisten Fällen (wie im vorherigen Schritt) die Parametervariablen zum Referenzieren und Ändern von Speicher, der im Programmwrapperobjekt reserviert wurde. Es folgt ein weiteres Beispiel, bei dem der Eingabedatensatz (in diesem Fall 'MyRecord') des EGL-Hauptprogramms über einen Java-Datensatz (in diesem Fall 'inputValue') mit Daten gefüllt wird:
      myProgram.setMyRecord(inputValue);
  • Definieren Sie eine Benutzer-ID und ein Kennwort, jedoch nur in folgenden Fällen:
    • Der Java-Wrapper greift mithilfe von iSeries Toolbox for Java auf ein iSeries-basiertes Programm zu.
    • Das generierte Programm wird in einer Region mit CICS für z/OS ausgeführt, das für eine Authentifizierung des Fernzugriffs sorgt.

    Die Benutzer-ID und das Kennwort werden nicht für den Datenbankzugriff verwendet.

    Mit der Variablen 'callOptions' des Programmobjekts können Sie die Benutzer-ID und das Kennwort wie im folgenden Beispiel definieren und prüfen:
      myProgram.callOptions.setUserID("myID");
      myProgram.callOptions.setPassword("myWord");
      myUserID = myProgram.callOptions.getUserID();
      myPassword = myProgram.callOptions.getPassword();
  • Ziehen Sie die Verwendung der folgenden Funktionalität in Betracht, die nur verfügbar ist, wenn es sich bei dem aufgerufenen Programm um ein EGL-Hauptprogramm handelt:
    • Geben Sie, wie im folgenden Beispiel dargestellt, eine Datenbankverbindung für das aufgerufene Programm an:
      // Eine Verbindung zur Datenbank wird hergestellt.
      Connection con = DriverManager.getConnection( "jdbc:db2://host:50000/db", "user", "pwd" );
      
      // Der Modus für automatisches Commit wird inaktiviert, um Transaktionen zu ermöglichen.
      con.setAutoCommit( false );
      
      // Der Wrapper wird erstellt und es wird eine Verbindung hinzugefügt.
      MWrapper mw = new MWrapper();
      mw.addConnection( con, "con1" );
      
      // Das Programm wird ausgeführt.
      mw.execute();
      
      // Die Arbeit wird festgeschrieben und es erfolgt eine Bereinigung.
      mw.getPowerServer().commit();
      mw.getPowerServer().close();
      con.close();
    • Greifen Sie, wie im folgenden Beispiel dargestellt, auf den Rückgabewert (den Wert von sysVar.returnCode) zu:
        int returnValue = myProgram.returnCode();
  • Greifen Sie auf das generierte Programm zu, indem Sie beispielsweise die Methode 'execute' des Programmwrapperobjekts aufrufen:
      myProgram.execute();  
    Sie können stattdessen auch die Methode 'call' verwenden und beim Methodenaufruf Argumente angeben. Es folgt ein weiteres Beispiel für die Verwendung von 'execute':
    myProgram.setParm1( 2 );
    myProgram.setParm2( "sell" );
    myProgram.execute();
    Der folgende Aufruf der Methode 'call' hat die gleiche Wirkung:
    myProgram.call( 2, "sell" );
  • Richten Sie mit dem Middlewareobjekt eine Datenbanktransaktionssteuerung ein, jedoch nur in der folgenden Situation:
    • Das Programmwrapperobjekt greift auf ein generiertes Programm in CICS für z/OS zu oder mit IBM® Toolbox for Java auf ein iSeries-basiertes COBOL-Programm. Im letzteren Fall lautet der Wert für remoteComType bei dem Aufruf JAVA400 oder JAVA400J2C.
    • Im Verbindungsoptionsabschnitt, der zum Generieren der Wrapperklassen verwendet wurde, haben Sie angegeben, dass die Arbeitseinheit für Datenbanken vom Client (in diesem Fall vom Wrapper) gesteuert wird. Nähere Angaben hierzu finden Sie in dem Abschnitt 'luwControl im Element 'callLink''.
    Wenn die Datenbankarbeitseinheit vom Client gesteuert wird, werden für die Verarbeitung die Methoden 'commit' und 'rollback' des Middlewareobjekts verwendet:
      powerServer.commit();
      powerServer.rollBack();

    Bei Verwendung eines einzelnen PowerServer-Objekts kann unter Umständen folgende Situation eintreten: Die EGL-Laufzeitumgebung schreibt eine über eine einleitende Verbindung vorgenommene Änderung fest, beim Festschreiben einer über eine zweite Verbindung vorgenommenen Änderung tritt jedoch ein Problem auf und das Festschreiben schlägt fehl. Nach einem Fehler verbleiben die Daten in einem inkonsistenten Status, da es sich bei dem Festschreiben um eine einphasige Festschreibung und nicht um eine zweiphasige Festschreibung handelt, sodass alle Ressourcen festgeschrieben werden oder keine.

  • Schließen Sie das Middlewareobjekt. Verwenden Sie dazu, wie zuvor in einem Beispiel dargestellt, die wrapperspezifische Methode getPowerServer().close(), wenn Sie das Objekt nicht explizit deklariert haben.

    Das Middlewareobjekt wird geschlossen, um die EGL-Ausführungseinheit zu beenden und eine Garbage-Collection zu ermöglichen:

    if ( powerServer != null )
    {
      try
      {
        powerServer.close();
        powerServer = null;
      }
      catch ( JavartException error )
      {
        System.out.println( "Error closing middleware" 
          + error.getMessage() );
        System.exit( 8 );
      }
    }

Programmwrapperklassen

Die Programmwrapperklasse enthält für jeden Parameter im generierten Programm eine private Instanzvariable. Wenn es sich bei dem Parameter um einen Datensatz oder ein Formular handelt, verweist die Variable auf eine Instanz der zugehörigen Parameterwrapperklasse. Basiert der Parameter auf einem DataItem-Abschnitt, weist die Variable einen Java-Basiselementtyp auf.

Eine Beschreibung zur Konvertierung zwischen EGL- und Java-Typen können Sie einer Tabelle am Ende dieser Hilfetextseite entnehmen.

Ein Programmwrapperobjekt enthält die folgenden öffentlichen Methoden:
  • Die Methoden get und set für die einzelnen Parameter, wobei folgendes Namensformat angewendet wird:
      ZweckParametername()
    Zweck
    Das Wort get oder set
    Parametername
    Der Name des Datenfelds, Datensatzes oder Formulars. Der erste Buchstabe ist ein Großbuchstabe. Die Schreibung der übrigen Zeichen richtet sich nach der im Abschnitt Namenskonventionen für Java-Wrapperklassen beschriebenen Namenskonvention.
  • Eine Methode execute für den Aufruf des Programms. Sie verwenden diese Methode, wenn sich die Daten, die als Argumente des Aufrufs übergeben werden sollen, in dem Speicher befinden, der für das Programmwrapperobjekt reserviert ist.
Wenn Sie keine Werte zu den Instanzvariablen zuordnen möchten, können Sie auch wie folgt vorgehen:
  • Reservieren Sie Speicher für Parameterwrapperobjekte, Wrapperobjekte für dynamische Feldgruppen und Basiselementtypen.
  • Ordnen Sie dem reservierten Speicher Werte zu.
  • Übergeben Sie diese Werte an das Programm, indem Sie statt der Methode execute die Methode call des Programmwrapperobjekts aufrufen.
Das Programmwrapperobjekt enthält auch die Variable callOptions, die folgendem Zweck dient:
  • Wenn Sie den Java-Wrapper so generiert haben, dass die Verbindungsoptionen für den Aufruf bei der Generierung festgelegt werden, enthält die Variable callOptions die Verbindungsinformationen. Nähere Angaben zu dem Zeitpunkt, zu dem die Verbindungsoptionen definiert werden, finden Sie im Abschnitt 'remoteBind im Element 'callLink''.
  • Wenn Sie den Java-Wrapper so generiert haben, dass die Verbindungsoptionen für den Aufruf zur Laufzeit festgelegt werden, enthält die Variable callOptions den Namen der Verbindungseigenschaftendatei. Der Dateiname lautet VO.properties, wobei VO für den Namen des bei der Generierung verwendeten Verbindungsoptionsabschnitts steht.
  • In beiden Fällen stellt die Variable callOptions die folgenden Methoden für das Definieren oder Abrufen einer Benutzer-ID und eines Kennworts bereit:
      setPassword(Kennwort)
      setUserid(BenutzerID) 
      getPassword()
      getUserid()
    Die Benutzer-ID und das Kennwort werden verwendet, wenn Sie die Eigenschaft remoteComType des Elements 'callLink' mit einem der folgenden Werte definieren:
    • CICSECI
    • CICSJ2C
    • JAVA400
    • JAVA400J2C
    Kennwortdaten können auch in der Datei csouidpwd.properties gespeichert werden. Lesen Sie dazu Benutzer-ID und Kennwort für ferne Aufrufe bereitstellen.
Die folgenden Methoden sind verfügbar, wenn ein EGL-Hauptprogramm aufgerufen wird:
  • returnCode() gibt den ganzzahligen Wert von sysVar.returnCode zurück.
  • addConnection() gibt ein JDBC-Verbindungsobjekt für das EGL-Hauptprogramm an. Bei jedem Aufruf von addConnection() wird die Verbindung als aktuelle Verbindung für die Ausführungseinheit zugeordnet.

    Die Ausführungseinheit kann zuvor angegebene Verbindungen, soweit vorhanden, verwenden. Wird jedoch eine derartige Verbindung von der Ausführungseinheit geschlossen, erfolgt die Freigabe und die Verbindung kann anschließend nicht erneut geöffnet werden. Die letztgenannte Einschränkung gilt, auch wenn das Schließen im EGL-Programm oder über einen Aufruf von powerServer.close() (wie in einem vorherigen Abschnitt dargestellt) erfolgt.

    addConnection() wird mit bis zu drei Argumenten aufgerufen. Bei dem letzten Argument handelt es sich um ein optionales Argument. Die Methodensignatur gestaltet sich folgendermaßen:
    public void addConnection
       (java.sql.Connection Verbindung, java.lang.String Name, int Option_für_Verbindungsabbruch)
       throws java.lang.NullPointerException, java.lang.IllegalArgumentException, com.ibm.javart.JavartException
    Folgende Parameter werden verwendet:
    • Verbindung (Typ 'java.sql.Connection') gibt eine Verbindung zu dem Typ von Datenbank an, der in der Builddeskriptoroption DBMS angegeben wurde.
    • Name (type java.lang.String) gibt den Namen der Verbindung an. Vom Hauptprogramm wird der Name bei einem Aufruf der folgenden Systemfunktionen verwendet: sqlLib.beginDatabaseTransaction(), sqlLib.defineDatabaseAlias(), sqlLib.disconnect() und sqlLib.setCurrentDatabase().
    • Option_für_Verbindungsabbruch (Typ 'int') gibt die Option für Verbindungsabbruch an. Zulässige Konstanten:
      • Der Standardwert DISCONNECT_NEVER gibt an, dass alle Versuche, die Verbindung zu trennen, erfolglos bleiben, Aufrufe von 'powerServer.close()' durch den aufrufenden Java-Code eingeschlossen.

        'powerServer.close()' bewirkt ein Festschreiben der Arbeit (Commit) und Beenden der EGL-Ausführungseinheit. Bei allen anderen Optionen für Verbindungsabbruch geht mit dem Beenden der EGL-Ausführungszeit das Schließen offener Verbindungen einher.

      • DISCONNECT_AUTOMATIC gibt an, dass die Verbindung nach einem Rollback, nach einem Festschreiben und nach einem Aufruf von sqlLib.disconnect() oder sqlLib.disconnectAll() durch das Hauptprogramm geschlossen wird.
      • DISCONNECT_CONDITIONAL gibt an, dass die Verbindung in den folgenden Fällen geschlossen wird: nach einem Rollback, nach einem Festschreiben, sofern die Option 'HOLD' nicht für eine von der Verbindung erstellte offene Ergebnismenge aktiv ist, und nach einem Aufruf von sqlLib.disconnect() oder sqlLib.disconnectAll() durch das Hauptprogramm.
      • DISCONNECT_EXPLICIT gibt an, dass die Verbindung nach einem Aufruf von 'sqlLib.disconnect()' oder 'sqlLib.disconnectAll()' durch das Hauptprogramm geschlossen wird, jedoch nicht nach einem Rollback oder Festschreiben.

      Mit Ausnahme des ersten Werts entsprechen die zuvor angegebenen Werte Werten, die Sie beim Aufruf der Systemfunktion sqlLib.connect() angeben können. Dabei handelt es sich um folgende Werte aus der EGL-Aufzählung egl.io.sql.DisconnectKind: DisconnectKind.automatic, DisconnectKind.conditional, DisconnectKind.explicit. Ein dem Wert DISCONNECT_NEVER entsprechender Wert kann bei Aufruf von sqlLib.connect() nicht angegeben werden.

Schließlich ist noch die folgende Situation möglich: Ihr nativer Java-Code erfordert eine Benachrichtigung, wenn ein Parameter eines Basiselementtyps geändert wird. Eine derartige Benachrichtigung wird ermöglicht, indem sich der native Code durch Aufruf der Methode addPropertyChangeListener des Programmwrapperobjekts als Listener registriert. In diesem Fall löst eine der folgenden Situationen das Ereignis 'PropertyChange' aus, bei dem der native Code zur Laufzeit eine Benachrichtigung empfängt:
  • Vom nativen Code wird für einen Parameter eines Basiselementtyps die Methode set aufgerufen.
  • Das generierte Programm gibt geänderte Daten an einen Parameter eines Basiselementtyps zurück.

Das Ereignis 'PropertyChange' wird in der JavaBean-Spezifikation von Oracle beschrieben.

Gruppe der Parameterwrapperklassen

Eine Parameterwrapperklasse wird für jeden Datensatz erzeugt, der als Parameter (oder Eingabedatensatz) im generierten Programm deklariert ist. Im Normalfall wird eine Parameterwrapperklasse nur zum Deklarieren einer Variablen verwendet, die den Parameter referenziert. Dazu folgendes Beispiel:
  Mypart myRecWrapperObject = myProgram.getMyrecord();

In diesem Fall verwenden Sie den vom Programmwrapperobjekt reservierten Speicher.

Sie können die Parameterwrapperklasse auch zum Deklarieren von Speicher verwenden. Dies ist notwendig, wenn Sie die Methode 'call' (und nicht die Methode 'execute') des Programmobjekts aufrufen.

Die Parameterwrapperklasse enthält die folgende Gruppe privater Instanzvariablen:
  • Eine Variable eines Java-Basiselementtyps für jedes einzelne Parameterstrukturfeld einer unteren Ebene, jedoch nur für Strukturfelder, bei denen es sich weder um eine Feldgruppe noch um ein Feld einer unterstrukturierten Feldgruppe handelt.
  • Eine Feldgruppe eines Java-Basiselementtyps für jedes einzelne EGL-Strukturfeld, bei dem es sich um eine Feldgruppe handelt, unterstrukturierte Feldgruppen ausgenommen
  • Ein Objekt einer untergeordneten Feldgruppenklasse für jede unterstrukturierte Feldgruppe, die nicht selbst in einer unterstrukturierten Feldgruppe enthalten ist. Die untergeordnete Klasse kann über weitere verschachtelte untergeordnete Klassen verfügen, um untergeordnete unterstrukturierte Feldgruppen darzustellen.
Die Parameterwrapperklasse enthält mehrere öffentliche Methoden:
  • Eine Gruppe von get- und set-Methoden, mit denen Sie die einzelnen Instanzvariablen abrufen und definieren können. Die Methodennamen haben folgendes Format:
      ZweckName_des_strukturierten_Felds()
    Zweck
    Das Wort get oder set.
    Name_des_strukturierten_Felds
    Der Name des strukturierten Felds. Der erste Buchstabe ist ein Großbuchstabe. Die Schreibung der übrigen Zeichen richtet sich nach der im Abschnitt Namenskonventionen für Java-Wrapperklassen beschriebenen Namenskonvention.
    Anmerkung: Strukturfelder, die von Ihnen als Platzhalter deklariert wurden, sind im Programmaufruf enthalten. Die Wrapperklassen für Feldgruppen enthalten jedoch keine öffentlichen get- und set-Methoden für diese Strukturfelder.
  • Mit der Methode equals können Sie bestimmen, ob die in einem anderen Objekt derselben Klasse gespeicherten Werte mit den im Parameterwrapperobjekt gespeicherten Werten identisch sind. Die Methode gibt nur true zurück, wenn die Klassen und Werte übereinstimmen.
  • Die Methode addPropertyChangeListener wird aufgerufen, wenn Ihr Programm benachrichtigt werden muss, sobald sich eine Variable eines Java-Basiselementtyps ändert.
  • Eine zweite Gruppe von get- und set-Methoden ermöglicht es Ihnen, die Nullanzeiger für die einzelnen Strukturfelder in einem SQL-Satzparameter abzurufen und zu definieren. Diese Methodennamen haben folgendes Format:
      ZweckName_des_strukturierten_FeldsNullIndicator()
    Zweck
    Das Wort get oder set.
    Name_des_strukturierten_Felds
    Der Name des strukturierten Felds. Der erste Buchstabe ist ein Großbuchstabe. Die Schreibung der übrigen Zeichen richtet sich nach der im Abschnitt Namenskonventionen für Java-Wrapperklassen beschriebenen Namenskonvention.

Gruppe der Wrapperklassen für Feldgruppen mit unterstrukturierten Feldern

Bei einer Wrapperklasse für Feldgruppen mit unterstrukturierten Feldern handelt es sich um eine untergeordnete Klasse einer Parameterklasse, die eine unterstrukturierte Feldgruppe im zugehörigen Parameter darstellt. Die Wrapperklasse für Feldgruppen mit unterstrukturierten Feldern enthält eine Gruppe privater Instanzvariablen, die auf die Strukturfelder der Feldgruppe, einschließlich der untergeordneten Strukturfelder, verweisen:
  • Eine Variable eines Java-Basiselementtyps für jedes einzelne Feldgruppenstrukturfeld einer unteren Ebene, jedoch nur für Strukturfelder, bei denen es sich weder um eine Feldgruppe noch um ein Feld einer unterstrukturierten Feldgruppe handelt.
  • Eine Feldgruppe eines Java-Basiselementtyps für jedes einzelne EGL-Strukturfeld, bei dem es sich um eine Feldgruppe handelt, unterstrukturierte Feldgruppen ausgenommen.
  • Ein Objekt einer untergeordneten Wrapperklasse für Feldgruppen mit unterstrukturierten Feldern für jede unterstrukturierte Feldgruppe, die nicht selbst in einer unterstrukturierten Feldgruppe enthalten ist. Die untergeordnete Klasse kann über untergeordnete Klassen verfügen, um untergeordnete unterstrukturierte Feldgruppen darzustellen.
Die Wrapperklasse für Feldgruppen mit unterstrukturierten Feldern enthält die folgenden Methoden:
  • Eine Reihe von get- und set-Methoden für jede Instanzvariable
    Anmerkung: Strukturfelder, die von Ihnen als Platzhalter ohne Namen deklariert wurden, werden im Programmaufruf verwendet. Die Wrapperklassen für Feldgruppen mit unterstrukturierten Feldern enthalten jedoch keine öffentlichen get- und set-Methoden für diese strukturierten Felder.
  • Mit der Methode equals können Sie bestimmen, ob die in einem anderen Objekt derselben Klasse gespeicherten Werte mit den Werten übereinstimmen, die im Wrapperobjekt für Feldgruppen mit unterstrukturierten Feldern gespeichert sind. Die Methode gibt nur true zurück, wenn die Klassen und Werte übereinstimmen.
  • Die Methode addPropertyChangeListener wird verwendet, wenn Ihr Programm benachrichtigt werden muss, sobald bei einer Variablen eines Java-Basiselementtyps eine Änderung eintritt.
In den meisten Fällen weist der Name der obersten Wrapperklasse für Feldgruppen mit unterstrukturierten Feldern in einer Parameterwrapperklasse folgendes Format auf:
  Parameterklassenname.Feldgruppenklassenname
Zur Veranschaulichung hier ein Beispieldatensatz:
  Record CompanyPart type basicRecord
  10 Departments CHAR(20)[5];
     20 CountryCode CHAR(10);
     20 FunctionCode CHAR(10)[3];
        30 FunctionCategory CHAR(4);
        30 FunctionDetail CHAR(6);
  end

Wenn der Parameter Company auf CompanyPart basiert, verwenden Sie als Namen der untergeordneten Klasse die Zeichenfolge CompanyPart.Departments.

Eine untergeordnete Klasse einer untergeordneten Klasse erweitert die Verwendung der Punktsyntax. Bei dem genannten Beispiel verwenden Sie das Symbol CompanyPart.Departments.Functioncode als Namen der untergeordneten Klasse von Departments.

Weitere Einzelheiten zur Namensgebung bei Wrapperklassen für Feldgruppen mit unterstrukturierten Feldern finden Sie im Abschnitt Ausgabe der Java-Wrappergenerierung.

Wrapperklassen für dynamische Feldgruppen

Eine Wrapperklasse für dynamische Feldgruppen wird für jede dynamische Feldgruppe erzeugt, die im generierten Programm als Parameter deklariert ist. Dazu folgende EGL-Programmsignatur als Beispiel:
  Program myProgram(intParms int[], recParms MyRec[])

Die Namen der Wrapperklassen für dynamische Feldgruppen sind IntParmsArray und MyRecArray.

Mit der Wrapperklasse für dynamische Feldgruppen können Sie eine Variable deklarieren, die die dynamische Feldgruppe referenziert. Dazu folgende Beispiele:
  IntParmsArray myIntArrayVar = myProgram.getIntParms();
  MyRecArray    myRecArrayVar = myProgram.getRecParms();

Nach dem Deklarieren der Variablen für die einzelnen dynamischen Feldgruppen können Sie bei Bedarf wie folgt Elemente hinzufügen:

  // Das Hinzufügen zu einer Feldgruppe mit Java-Basiselementen 
  // erfolgt in einem Schritt.
  myIntArrayVar.add(new Integer(5));

  // Das Hinzufügen zu einer Feldgruppe mit Datensätzen oder Formularen 
  // erfordert mehrere Schritte. In diesem Fall wird mit dem 
  // Zuordnen eines neuen Satzobjekts begonnen.
  MyRec myLocalRec = (MyRec)myRecArrayVar.makeNewElement();
  
  // Die Schritte für die Zuordnung von Werten sind in diesem 
  // Beispiel nicht gezeigt. Fügen Sie nach dem Zuordnen von 
  // Werten den Datensatz zur Feldgruppe hinzu.
  myRecArrayVar.add(myLocalRec);

  // Es schließt sich die Ausführung des Programms an.
  myProgram.execute();

  // Nach Rückkehr des Programms können Sie die 
  // Anzahl der Elemente in der Feldgruppe bestimmen.
  int myIntArrayVarSize = myIntArrayVar.size();

  // Rufen Sie das erste Element der Integer-Feldgruppe ab und 
  // setzen Sie es als Integer-Objekt um.
  Integer firstIntElement = (Integer)myIntArrayVar.get(0);

  // Rufen Sie das zweite Element der Satzfeldgruppe ab.
  // setzen Sie es in ein Objekt 'MyRec' um.
  MyRec secondRecElement = (MyRec)myRecArrayVar.get(1);

Wie im Beispiel angedeutet stellt EGL verschiedene Methoden für die Bearbeitung der von Ihnen deklarierten Variablen bereit.

Methode der Klasse für dynamische Feldgruppen Zweck
add(int, Objekt) Einfügen eines Objekts an der durch int angegebenen Position und Verschieben des aktuellen Elements sowie der nachfolgenden Elemente nach rechts
add(Objekt) Anfügen eines Objekts am Ende der dynamischen Feldgruppe
addAll(Feldgruppenliste) Anfügen einer Feldgruppenliste am Ende der dynamischen Feldgruppe
get() Abrufen des Feldgruppenlistenobjekts, das alle Elemente der Feldgruppe enthält
get(int) Abrufen des Elements, das sich an der durch int angegebenen Position befindet
makeNewElement() Zuordnen eines neuen Elements des feldgruppenspezifischen Typs und Abrufen dieses Elements, ohne es zur dynamischen Feldgruppe hinzuzufügen
maxSize() Abrufen eines ganzzahligen Werts, der die maximale (nicht die tatsächliche) Anzahl von Elementen in der dynamischen Feldgruppe angibt
remove(int) Entfernen des Elements, das sich an der durch int angegebenen Position befindet
set(Feldgruppenliste) Verwenden der angegebenen Feldgruppenliste als Ersatz für die dynamische Feldgruppe
set(int, Objekt) Verwenden des angegebenen Objekts als Ersatz für das Element, das sich an der von int angegebenen Position befindet
size() Abrufen der Anzahl von Elementen in der dynamischen Feldgruppe
Ausnahmebedingungen treten unter anderem in folgenden Fällen ein:
  • Sie geben in der Methode get oder set einen ungültigen Index an.
  • Sie versuchen, ein Element hinzuzufügen (oder zu definieren), dessen Klasse nicht mit der Klasse der einzelnen Elemente in der Feldgruppe kompatibel ist.
  • Sie versuchen, Elemente zu einer dynamischen Feldgruppe hinzuzufügen, deren maximale Größe kein weiteres Hinzufügen zulässt. Wenn die Methode addAll aus diesem Grund fehlschlägt, werden keine Elemente von der Methode hinzugefügt.

Namenskonventionen für Java-Wrapperklassen

Namen werden von EGL gemäß den folgenden Regeln erstellt:
  • Besteht ein Name nur aus Großbuchstaben, wird der gesamte Name in Kleinbuchstaben umgesetzt.
  • Handelt es sich bei einem Namen um ein Schlüsselwort, wird ein Unterstreichungszeichen vorangestellt.
  • Enthält ein Name einen Bindestrich oder ein Unterstreichungszeichen, wird dieses Zeichen entfernt und der nächste Buchstabe in einen Großbuchstaben umgesetzt.
  • Enthält ein Name ein Dollarzeichen ($), ein kommerzielles A (@) oder ein Nummernzeichen (#), wird jedes dieser Zeichen durch ein doppeltes Unterstreichungszeichen (__) ersetzt und dem Namen ein Unterstreichungszeichen (_) vorangestellt.
  • Wird ein Name als Klassenname verwendet, wird der erste Buchstabe in einen Großbuchstaben umgesetzt.
Für Wrapperklassen für dynamische Feldgruppen gelten die folgenden Regeln:
  • In den meisten Fällen basiert der Name einer Klasse auf dem Namen der Abschnittsdeklaration (Datenelement, Formular oder Datensatz), die die Basis jedes Elements in der Feldgruppe darstellt. Wenn ein Datensatzabschnitt beispielsweise den Namen MyRec und die Feldgruppendeklaration den Namen recParms myRec[] hat, lautet der Name der zugehörigen Wrapperklasse für dynamische Feldgruppen MyRecArray.
  • Basiert die Feldgruppe auf einer Deklaration, für die keine zugehörige Abschnittsdeklaration vorliegt, orientiert sich der Name der Klasse für dynamische Feldgruppen an dem Namen der Feldgruppe. Lautet der Name der Feldgruppendeklaration z. B. intParms int[], wird die zugehörige Wrapperklasse für dynamische Feldgruppen mit dem Namen IntParmsArray bezeichnet.

Querverweise für Datentypen

Die nachfolgende Tabelle gibt Aufschluss über die Beziehung zwischen EGL-Basiselementtypen im generierten Programm und den Java-Datentypen im generierten Wrapper.

EGL-Basiselementtyp Länge in Zeichen oder Stellen Länge in Bytes Dezimalstellen Java-Datentyp Maximale Genauigkeit in Java
BIN, SMALLINT 4 2 0 short 4
BIN, INT 9 4 0 int 9
BIN, BIGINT 18 8 0 long 18
BIN 4 2 >0 float 4
BIN 9 4 >0 double 15
BIN 18 8 >0 double 15
BOOLEAN 1 1 - Boolean -
CHAR 1-32767 2-32766 - String -
DBCHAR 1-16383 1-32767 - String -
DATE 8 8 0 java.sql.Date -
DECIMAL, MONEY, PACF 1-3 1-2 0 short 4
DECIMAL, MONEY, PACF 4-9 3-5 0 int 9
DECIMAL, MONEY, PACF 10-18 6-10 0 long 18
DECIMAL, MONEY, PACF 19-32 10-17 0 java.math.BigInteger 32
DECIMAL, MONEY, PACF 1-5 1-3 >0 float 6
DECIMAL, MONEY, PACF 7-18 4-10 >0 double 15
DECIMAL, MONEY, PACF 19-32 10-17 >0 java.math.BigDecimal 32
FLOAT 18 8 >0 double 15
HEX 2-75534 1-32767 - byte[] -
INTERVAL (Zeitspanne in Monaten oder Sekunden) 1-21 2-22 0 String -
MBCHAR 1-32767 1-32767 - String -
NUM, NUMC 1-4 1-4 0 short 4
NUM, NUMC 5-9 5-9 0 int 9
NUM, NUMC 10-18 10-18 0 long 18
NUM, NUMC 19-32 19-32 0 java.math.BigInteger 32
NUM, NUMC 1-6 1-6 >0 float 6
NUM, NUMC 7-18 7-18 >0 double 15
NUM, NUMC 19-32 19-32 >0 java.math.BigDecimal 32
SMALLFLOAT 9 4 >0 float 6
STRING 1-16383 2-32766 - String -
TIME 6 6 0 java.sql.Time -
TIMESTAMP 1-20 1-20 0 java.sql. Timestamp -
UNICODE 1-16383 2-32766 - String -

Feedback