Muster

Bei der Deserialisierung von bedingten Transformationen wird als Kriterium für die Auswertung herangezogen, ob der Template-Inhalt ein so genanntes Muster (engl. Pattern) ist. Ein Muster enthält ein oder mehrere Konstrukte, die als "Marker" dienen. Die häufigste Form eines Markers ist ein literales XML-Element: Besteht der Inhalt der Bedingung aus genau einem XML-Element, so hat die Bedingung genau dann ein positives Ergebnis, wenn ein XML-Element mit diesem Namen an der aktuellen Stelle im XML-Eingabestrom folgt.

Marker-Konstrukte sind:

Literales XML-Element mit oder ohne Inhalt
Nicht-literales Attribut mit Inhalt
Nicht-leerer literaler Text
Ein explizit leerer Template-Inhalt

Jedes dieser Konstrukte kann in offensichtlicher Weise mit dem Eingabestrom abgeglichen werden.

Im allgemeinen kann ein Muster mehrere Marker enthalten. Beispielsweise. ist auch die Sequenz

Syntax Syntax

```
<tt:cond>
```
```
  <X> ... </X>
```
```
</tt:cond>
```
```
<Y> ... </Y>
```

Ende des Codes

ein Muster; es enthält die Marker <X> und <Y>. Eine Bedingung mit diesem Muster wird sowohl durch ein Element X als auch durch ein Element Y im Eingabestrom positiv entschieden (im zweiten Fall wird die Bedingung mit X negativ entschieden).

Im folgenden wird die Menge der in einem Template-Inhalt c enthaltenen Marker-Konstrukte M(c) rekursiv definiert. Der Template-Inhalt c ist dann ein Muster, wenn M(c) nicht leer ist. Kurz gesagt besteht M(c) aus den Markern, die zur positiven Erkennung des Musters c dienen können, wobei Bedingungen in einem Anfangsstück von c auch negativ entschieden werden können.

M(c) = {c} für Marker c. D.h., jeder Marker ist ein (primitives) Muster; die Markermenge dieses Musters besteht aus dem Marker selbst.

Einige Konstrukte propagieren Marker nach außen:

M(tt:deserialize) = M(tt:ref) = M(c) für den Inhalt c des jeweiligen Konstrukts.
M(tt:apply) = M(c) für den Rumpf c des gerufenen Templates.
M(tt:loop) = M(c) für den Schleifenrumpf c.

Bedingte Transformationen propagieren Marker ebenfalls; bei Fallunterscheidungen und Gruppierungen wird die Vereinigung über alle Fälle gebildet:

M(tt:[d-]cond) = M(c) für den Bedingungsrumpf c.
M(tt:group) = M(tt:switch) = M(c₁) U ... U M(c_n) für alle Fälle c_i = tt:[d-]cond

Für alle anderen Instruktionen c ist M(c) leer.

Abschließend gilt für Sequenzen c_ic₂ ... von Template-Inhalt die Regel:

M(c_ic₂ ...) = M(c₁) U M(c₂ ...) , falls c₁ ein Vor-Muster (engl. Pre-Pattern) ist = M(c₁) , sonst

Ein Template-Inhalt ist ein Vor-Muster, falls seine Deserialisierung ohne den Verbrauch von Inhalt aus dem Eingabestrom möglich ist. Im Detail:

Alle Konstrukte mit leerer Deserialisierung sind Vor-Muster. Dies sind tt:s-cond, tt:assign, tt:clear, tt:serialize, tt:write, sowie Zusammensetzungen davon mit tt:cond-var, tt:switch-var und tt:apply.
tt:[d-]cond ist ein Vor-Muster, falls der Bedingungsrumpf ein Muster ist. (Denn wenn das Muster nicht abgeglichen werden kann, wird die Bedingung negativ entschieden und übersprungen.)
tt:deserialize, tt:ref und tt:apply propagieren die Vor-Muster-Eigenschaft.

Beispiel

Der Inhalt des folgenden tt:cond ist ein Muster mit den Marker-Elementen {f1, f2, f3} (aber nicht fx).

Syntax Syntax

<tt:cond s-check="not-initial(F3) and initial(F6)">

```
  <tt:clear ref="F3"/>
```

  <tt:cond check="not-initial(F1) or not-initial(F2)">

```
    <tt:cond check="not-initial(F1)">
```
```
      <tt:clear ref="F1"/>
```
```
      <tt:serialize>
```
```
        <f1 a="v" tt:value-ref="F1"/>
```
```
      </tt:serialize>
```
```
      <tt:deserialize>
```
```
        <f1 tt:value-ref="F1"/>
```
```
      </tt:deserialize>
```
```
    </tt:cond>
```
```
    <f2 tt:value-ref="F2"/>
```
```
  </tt:cond>
```
```
  <f3 tt:value-ref="F3"/>
```
```
  <fx> ... </fx>
```
```
</tt:cond>
```

Ende des Codes