Eigenschaften

Eigenschaften sind Name/Wert-Paare, die von EGL verwendet werden, um bestimmte Informationen zu einem Abschnitt, einer Variablen oder einer Anweisung zu codieren. EGL definiert diese Eigenschaften intern auf unterschiedliche Art und Weise. EGL-Programmierer brauchen lediglich eine Reihe wichtiger Unterschiede zu kennen:
  • Eine einfache Eigenschaft überträgt Informationen zur Generierungszeit an EGL und kann nicht dynamisch (d. h. zur Ausführungszeit) geändert werden. Eine einfache Eigenschaft verfügt nur über ein einziges Feld: value (Wert). Sie können eine Kurzform verwenden, um dieses Feld zu setzen, indem Sie einfach den Eigenschaftsnamen mit dem gewünschten Wert in einem SET-Werteblock gleichsetzen (siehe SET-Werteblöcke). Im folgenden Beispiel ist 'displayName' eine einfache Eigenschaft:
    DataItem socSecNum INT {
       displayName = "Social Security Number"} 
    end
  • Eine komplexe Eigenschaft überträgt Informationen ebenfalls zur Generierungszeit an EGL und kann nicht zur Ausführungszeit geändert werden. Eine komplexe Eigenschaft unterscheidet sich von einer einfachen Eigenschaft nur darin, dass sie nicht nur ein Feld, sondern mehrere Felder hat. Jedes dieser Name/Wert-Paare wird als Eigenschaftsfeld bezeichnet. Einer komplexen Eigenschaft wird häufig der monadische Operator '@' vorangestellt, um anzugeben, dass es sich bei dem Operanden um eine Eigenschaft und nicht um ein Feld handelt (siehe Operator '@'). Lesen Sie hierzu auch den Abschnitt 'Komplexe Eigenschaften' in diesem Thema.
  • Ein implizites Feld ist ein Name/Wert-Paar, das einer Eigenschaft ähnlich ist, aber zur Buildzeit nicht für den Compiler sichtbar ist. Generell sind diese impliziten Felder zur Ausführungszeit änderbar. EGL fügt sie automatisch zu den Abschnitten eines bestimmten Stereotyps wie beispielsweise Ausnahmedatensätzen hinzu (siehe Der Stereotyp 'Exception').
  • Darüber hinaus gibt es "Pseudoeigenschaften" in Console UI . Ebenso wie einfache Eigenschaften sind auch Pseudoeigenschaften Name/Wert-Paare, die bei der Deklaration bestimmter Variablentypen (wie beispielsweise 'ConsoleField') angegeben werden können. Im Gegensatz zu einfachen Eigenschaften haben sie jedoch keine Auswirkung auf die Generierung. Diese Pseudoeigenschaften sind häufig zur Ausführungszeit änderbar, wenngleich einige auch als schreibgeschützt deklariert werden. Weitere Informationen finden Sie in den Abschnitten zur relevanten Benutzerschnittstellentechnologie.

In dieser Dokumentation wird der Begriff 'Eigenschaften' breitgefasst für alle vorstehenden Varianten verwendet.

Sie können alle diese Eigenschaften in einem SET-Werteblock setzen. Eine ausführlichere Beschreibung hierzu finden Sie unter SET-Werteblöcke. Weitere Informationen zu den Eigenschaften und Werten, die für einen bestimmten Abschnitt oder eine bestimmte Anweisung verfügbar sind, finden Sie in den einschlägigen Themen zu den Eigenschaften dieser Abschnitte und Anweisungen.

Welche Eigenschaften gültig sind, ist vom jeweiligen Kontext abhängig:
  • Für jeden Abschnittstyp ist eine Gruppe von Eigenschaften definiert. Sie können diese Eigenschaften ändern, um die Merkmale des betreffenden Abschnitts zu modifizieren. Jeder Programmabschnitt beispielsweise enthält eine Eigenschaft namens 'alias', die den Namen der kompilierbaren Einheit angibt.

    Ist ein Abschnitt stereotypisiert, sind zusätzliche Eigenschaften verfügbar (siehe Stereotype), und zwar möglicherweise nicht nur für den Abschnitt selbst, sondern auch für die enthaltenen Felder. Weitere Informationen finden Sie in den Themen zu den speziellen Datenzugriffs- und Benutzerschnittstellentechnologien, für die der Stereotyp den betreffenden Abschnitt anpasst.

  • In einigen Variablendeklarationen können Sie eine Eigenschaft überschrieben, die in der zugehörigen Abschnittsdefinition angegeben wurde. Dies ist jedoch nur dann möglich, wenn die betreffende Eigenschaft in diesem Kontext aussagekräftig ist:
    • Eigenschaften können überschrieben werden, wenn Sie eine Variable deklarieren, die auf einem Datenelementabschnitt (DataItem) basiert (siehe DataItem-Abschnitt). Betrachten Sie die folgende Definition:
        DataItem IDNumber CHAR(9) 
        {
          minimumInput = 9,         // erfordert 9 Eingabezeichen
          isDecimalDigit = yes, // erfordert Ziffern
          column = "SSN"    // bezieht sich auf eine Spalte
        }
        end
      Die folgende Anweisung deklariert ein Benutzerschnittstellenfeld des Typs IDNumber, wobei nicht erforderlich ist, dass der Benutzer Ziffern eingibt:
        myID IDNumber { isDecimalDigit = no }; 

      In diesem Beispiel hat die Überschreibung keine Auswirkung auf die Eigenschaften 'minimumInput' und 'column'.

    • Sie können Eigenschaften von kombinierten Abschnitten wie beispielsweise Datensatzabschnitten überschreiben. Das folgende Beispiel definiert einen Datensatz mit einem einzelnen Feld:
      Record TestRecord
        y int {color = red};
      end
      Wenn Sie eine Variable auf der Basis dieser Definition deklarieren, können Sie den Wert der Eigenschaft color (Farbe) überschreiben:
      myRec TestRecord {y{color = black}};
  • Wenn Sie eine Variable eines Basiselementtyps deklarieren, können Sie alle Eigenschaften auf Feldebene setzen, die im Kontext der Variablendeklaration nützlich sind.
  • Wenn Sie eine Datensatzvariable deklarieren, können Sie die Eigenschaft 'redefines' zuordnen, die bei der Definition eines Abschnitts nicht gesetzt werden kann. Details zu dieser Eigenschaft finden Sie im Thema 'Datensatzvariable für erneute Definition einer anderen Variablen deklarieren'.

Auf einfache und komplexe Eigenschaften kann zur Ausführungszeit nicht zugegriffen werden. (Möglicherweise können Sie auf implizite Felder zugreifen.) Wenn Sie beispielsweise Variablen erstellen, die für relationale Datenbanksätze stereotypisiert sind, kann die von Ihnen geschriebene Logik keine Namen abrufen oder ändern, die der Eigenschaft 'tableNames' zugeordnet sind, mit der die Datenbanktabellen angegeben werden, auf die der Datensatz zugreift. Selbst wenn Sie einen Eigenschaftswert in einer Variablendeklaration überschreiben, kann Ihre Programmlogik den Wert, den Sie zur Entwicklungszeit angeben, nicht ändern.

Der fehlende Zugriff auf solche Eigenschaftswerte zur Ausführungszeit bedeutet, dass bei der Zuordnung des Inhalts einer Variablen oder bei der Verwendung der Variablen als Parameter der entsprechende Eigenschaftswert nicht zusammen mit dem Inhalt übertragen wird. Ebenso gilt: Wenn Sie einen Datensatz an eine EGL-Funktion übergeben, empfängt der Parameter zwar den Feldinhalt, behält jedoch die Eigenschaften bei, die zur Entwicklungszeit zugeordnet wurden. Mit anderen Worten: Die Funktion kann keine Überschreibungen erkennen, die das Programm an Datensatzeigenschaften vorgenommen hat.

Variablennamen und Eigenschaften

Wenn Sie den Namen einer EGL-Variablen einer Eigenschaft zuordnen, verwenden Sie den Variablennamen direkt. Schließen Sie den Namen nicht in Anführungszeichen ein, da diese eine Literalzeichenfolge angeben. Befolgen Sie diese Regel für die folgenden Eigenschaften:
Basisprogramm
inputRecord
JSF-Handler-Stereotyp
onConstructionFunction, initialUI-Feldgruppenelemente
Rich UI-Handler-Stereotyp
onConstructionFunction, validationByPassFunctions, validatorFunction, viewRootVar.
SQLRecord-Stereotyp
keyItems
Sonstige Eigenschaften
msgField, numElementsItem, selectedIndexItem, selectedRowItem, selectedValueItem , selectFromListItem, validatorDataTable, validatorFunction, redefines

Komplexe Eigenschaften

In bestimmten Fällen können Sie Merkmale für die Generierung angeben, indem Sie eine (aus einer Gruppe von Eigenschaftsfeldern bestehende) komplexe Eigenschaft zuordnen. Das folgende Beispiel deklariert einen EGL-Service und definiert die komplexe Eigenschaft 'xml', die die erforderlichen Details für die Bereitstellung des Zugriffs auf den Service enthält:
myService ExampleService {
   @xml {
      name="HelloWorld",
      namespace="http://my.website/services"} }
...
end

Zur Ausführungszeit kann weder auf die komplexe Eigenschaft selber noch auf ihre Eigenschaftsfelder zugegriffen werden.

Zuordnung und Eigenschaften

Eigenschaften werden nicht übertragen, wenn Sie eine Wertevariable einer anderen Wertevariablen zuordnen. Betrachten Sie folgendes Szenario:
  myVar1 INT {color = red} = 5;
  myVar2 INT {color = blue} = 2;

  myVar1 = myVar2;

Nach der Zuordnung hat myVar1 den Wert 2 und rot als Farbe.

Dasselbe wird erreicht, wenn Sie eine Variable als Argument an eine Funktion übergeben. Die Funktion empfängt den Wert der Variablen, aber keine ihrer Eigenschaften.

Referenzvariablen weisen ein anderes Verhalten auf. Wenn Sie Eigenschaften zu einer Referenzvariablen zuordnen, dann erfolgt die Zuordnung zu dem Objekt, auf das die Variable zeigt. Nach einer Zuordnung zeigt eine zweite Referenzvariable auf dasselbe Objekt. Das folgende Beispiel zeigt die Zuordnung einer Referenzvariablen:
myDictionary1 Dictionary { caseSensitive=NO };
myDictionary2 Dictionary { caseSensitive=YES };

myDictionary1 = myDictionary2;

Nach der Zuordnung zeigt myDictionary1 auf denselben Wörterverzeichnisabschnitt (Dictionary) wie myDictionary2, sodass bei myDictionary1 nun die Groß-/Kleinschreibung beachtet werden muss.