Fallunterscheidung
Um aus einer Menge bedingter Transformationen maximal eine auszuführen, kann die Anweisung tt:switch verwendet werden:
<tt:switch>
case1
case2
...
</tt:switch>
In tt:switch kann eine Liste von Fällen case1, case2, ... aufgeführt werden. Syntaktisch wird jeder Fall case1, case2, ... durch eine bedingte Transformation, d.h. ein Unterelement tt:[s-|d-]cond. formuliert. Dabei definiert tt:[s-]cond. einen serialisierungs-relevanten und tt:[d-]cond. einen deserialisierungs-relevanten Fall. Andere direkte Unterelemente sind in tt:switch nicht möglich.
Im Gegensatz zu bedingten Transformationen, die außerhalb von tt:switch stehen, muss bei einem Fall nicht mindestens ein Attribut using, data oder check angegeben werden, wenn der Inhalt von tt:[s-|d-]cond kein Muster ist.
In der Liste von Fällen case1, case2, ... ist folgendes zu beachten:
· Es darf maximal ein serialisierungs-relevanter Fall angegeben werden, in dem kein Attribut using, data oder check angegeben ist. Dieser Fall wird als Standard-Serialisierung bezeichnet.
· Es darf maximal ein deserialisierungs-relevanter Fall angegeben werden, der kein Muster enthält. Dieser Fall wird als Standard-Deserialisierung bezeichnet.
Serialisierung
Die Serialisierung erfolgt nach folgenden Regeln:
...
1. Der erste serialisierungs-relevante Fall tt:[s-]cond, dessen explizit angegebene Voraussetzungen erfüllt sind, wird serialisiert und das Element tt:switch verlassen.
2. Falls für keinen serialisierungs-relevanten Fall mit explizit angegebenen Attributen using, data oder check die Voraussetzung erfüllt ist, wird, falls vorhanden, die Standard-Serialisierung ausgeführt und das Element tt:switch verlassen.
3. Falls keine Standard-Serialisierung vorhanden ist, kommt es zur Ausnahme CX_ST_SWITCH_NO_CASE.
Bei einer erfolgreichen Serialisierung wird also genau ein Fall ausgeführt.
Deserialisierung
Die Deserialisierung erfolgt nach folgenden Regeln:
...
1. Der erste deserialisierungs-relevante Fall tt:[d-]cond, der ein passendes Muster enthält und dessen Voraussetzungen erfüllt sind, wird ausgeführt (Deserialisierung und Erfüllung der Zusicherungen) und das Element tt:switch verlassen.
2. Falls kein deserialisierungs-relevanter Fall, der ein Muster enthält, ausgeführt werden kann, wird versucht, die Standard-Deserialisierung , falls vorhanden, auszuführen. Nach der Ausführung wird das Element tt:switch verlassen. Falls die eventuellen Voraussetzungen using, data oder check der Standard-Deserialisierung nicht erfüllt sind, kommt es zur Ausnahme CX_ST_REF_ACCESS.
3. Falls keine Standard-Deserialisierung vorhanden ist, kommt es zur Ausnahme CX_ST_SWITCH_NO_CASE.
Bei einer erfolgreichen Deserialisierung wird also genau ein Fall ausgeführt.
Hinweis
Bei der Programmierung von Fallunterscheidungen sollten Serialisierung und Deserialisierung soweit wie möglich in gemeinsamen Fällen tt:cond formuliert werden, während die gerichteten Fälle tt:s-cond und tt:d-cond nur dann eingesetzt werden sollten, wo keine gemeinsame Formulierung möglich ist.
Beispiel
Die folgende Transformation setzt bei der Serialisierung das Attribut size des Elements Paragraph in Abhängigkeit vom Wert des Datenknotens SIZE auf genau einen von Wert “Small“, “Big“ oder “Medium“, wobei “Medium“ bei der Standard-Serialisierung erzeugt wird.
<tt:transform xmlns:tt="http://www.sap.com/transformation-templates">
<tt:root name="SIZE"/>
<tt:template>
<Paragraph>
<tt:attribute name="size">
<tt:switch>
<tt:s-cond check="SIZE<10">
<tt:text>Small</tt:text>
</tt:s-cond>
<tt:s-cond check="SIZE>20">
<tt:text>Big</tt:text>
</tt:s-cond>
<tt:s-cond>
<tt:text>Medium</tt:text>
</tt:s-cond>
<tt:d-cond using="exist(SIZE)" data="SIZE=8">
<tt:text>Small</tt:text>
</tt:d-cond>
<tt:d-cond using="exist(SIZE)" data="SIZE=16">
<tt:text>Medium</tt:text>
</tt:d-cond>
<tt:d-cond using="exist(SIZE)" data="SIZE=28">
<tt:text>Big</tt:text>
</tt:d-cond>
<tt:d-cond using="exist(SIZE)" data="SIZE=12">
<tt:skip/>
</tt:d-cond>
</tt:switch>
</tt:attribute>
<tt:text>Text</tt:text>
</Paragraph>
</tt:template>
</tt:transform>
Das Resultat sieht bei Eingabewerten für SIZE zwischen 10 und 20 beispielsweise wie folgt aus:
<Paragraph size="Medium">Text</Paragraph>
Bei der Deserialisierung wird dem Datenknoten SIZE für jedes der drei gültigen Attributwerte “Small“, “Medium“ und “Big“ über data ein Wert 8, 16 oder 28 zugewiesen. Wenn ein anderer Attributwert angegeben ist, wird SIZE in der Standard-Deserialisierung der Wert 12 zugewiesen und das ungültige Attribut mit tt:skip übersprungen.
In obiger Transformation werden Serialisierung und Deserialisierung vollständig getrennt behandelt und innerhalb eines einzigen tt:switch-Elements auseinandergesteuert. Da es keinen gemeinsamen Fall für Serialisierung und Deserialisierung gibt, kann man mit gleichem Ergebnis auch tt:serialize und tt:deserialize und zwei tt:switch-Elemente verwenden, wobei dann die Kennungen s- und d- vor cond entfallen können und die Abfrage, ob SIZE an ein ABAP-Datenobjekt angebunden ist, nur einmal gemacht werden muss:
<tt:transform xmlns:tt="http://www.sap.com/transformation-templates">
<tt:root name="SIZE"/>
<tt:template>
<Paragraph>
<tt:attribute name="size">
<tt:serialize>
<tt:switch>
<tt:cond check="SIZE<10">
<tt:text>Small</tt:text>
</tt:cond>
<tt:cond check="SIZE>20">
<tt:text>Big</tt:text>
</tt:cond>
<tt:cond>
<tt:text>Medium</tt:text>
</tt:cond>
</tt:switch>
</tt:serialize>
<tt:deserialize>
<tt:cond using="exist(SIZE)">
<tt:switch>
<tt:cond
data="SIZE=8">
<tt:text>Small</tt:text>
</tt:cond>
<tt:cond
data="SIZE=16">
<tt:text>Medium</tt:text>
</tt:cond>
<tt:cond
data="SIZE=28">
<tt:text>Big</tt:text>
</tt:cond>
<tt:cond
data="SIZE=12">
<tt:skip/>
</tt:cond>
</tt:switch>
</tt:cond>
</tt:deserialize>
</tt:attribute>
<tt:text>Blahblah</tt:text>
</Paragraph>
</tt:template>
</tt:transform>