Übersicht collectors

Mithilfe von collectors können Werte verschiedener Literalen aggregiert, gefiltert oder zusammengefasst werden. Fast alle von ihnen teilen sich zwei Eigenschaften:

• Der Zeitpunkt und die Art der Emission ihrer Werte ist steuerbar.
• Es ist möglich, sie nur dann auszuführen, wenn gewisse Bedingungen erfüllt sind.

Zudem ist es für die collectors combine, concat, equalsFilter, square, tuples, choose, range und group möglich, mittels <postprocess> Literal-Funktionen auf das Ergebnis anzuwenden. Beispiel:

<combine name="neu" value="${nachname}, ${vorname}">
  <data source="feld1" name="vorname"/>
  <data source="feld2" name="nachname"/>
  <postprocess>
    <trim/>
    <case to="upper"/>
  </postprocess>
</combine>

Folgend eine Liste der verfügbare collectors in Metamorph.

combine

combine fügt Literale gemäss einem Template zusammen. Nachfolgende Werte überschreiben vorangehenden Werte desselben Feldes.

• name (erforderlich): Name des neuen Feldes
• value (erforderlich): Template. Werte von Feldern können mit ${feldname} eingefügt werden

{ farbeA: grün, farbeA: gelb, farbeB: orange, farbeB: violet }

<combine name="mischung" value="${a}${b}">
  <data source="farbeA" name="a"/>
  <data source="farbeB" name="b"/>
</combine>

{ mischung: gelborange, mischung: gelbviolet }

concat

concat fügt Literale in der angegebenen Reihenfolge in einem neuen Feld zusammen. Werte desselben Feldes werden konkateniert.

• name (erforderlich): Name des neuen Feldes
• delimiter: Trennzeichen zwischen einzelnen Literalen (Standard: "")
• prefix: Präfix des neuen Feldes
• postfix: Suffix des neuen Feldes
• reverse: Fügt neue Literale am Anfang statt am Ende des neuen Feldes hinzu

{ farbeA: grün, farbeA: gelb, farbeB: orange, farbeB: violet }

<concat name="mischung" delimiter="">
  <data source="farbeA" name="a"/>
  <data source="farbeB" name="b"/>
</concat>

{ mischung: grüngelborangeviolet }

entity

entity erstellt mit den definierten Literalen eine neue (Sub-)Entität.

name definiert den Namen der Entität, der alternativ auch mit dem entity-name-Element definiert werden kann. Wird weder name noch entity-name angegeben, wird ein leerer Name gesendet.

{ farbeA: rot, farbeB: grün, farbeC: blau, farbeD: magenta }

<entity name="rgb" flushWith="record">
  <data source="farbeA"/>
  <data source="farbeB"/>
  <data source="farbeC"/>
</entity>
<data source="_else" />

{ farbeD: magenta, rgb { farbeA: rot, farbeB: grün, farbeC: blau }}

square

square fügt Literale zu allen möglichen nicht-permutierten Zweierkombinationen zusammen. Werte desselben Feldes werden nicht überschrieben.

• name (erforderlich): Name der neuen 2er-Tupel
• delimiter (erforderlich): Trennzeichen zwischen den ausgegebenen Literalen
• prefix: Präfix der 2er-Tupel
• postfix: Suffix der 2er-Tupel

{ litA: wertA1, litA: wertA2, litB: wertB1, litC: wertC1 }

<square name="paar" delimiter="-" prefix="@" postfix="@">
  <data source="litA"/>
  <data source="litB"/>
  <data source="litC"/>
</square>

{ paar: @wertA1-wertC1@, paar: @wertA2-wertC1@, paar: @wertB1-wertC1@, paar: @wertA1-wertB1@, paar: @wertA2-wertB1@, paar: @wertA1-wertA2@ }

tuples

tuples gibt alle möglichen nicht-permutierten Kombinationen der Literalwerte aus.

• name (erforderlich): Name der neuen Literale
• separator: Trennzeichen zwischen den Literalen

{ litA: wertA1, litA: wertA2, litB: wertB }

<tuples name="gruppen" separator="-">
  <data source="litA"/>
  <data source="litB"/>
</tuples>

{ gruppen: wertA1-wertB, gruppen: wertA2-wertB }

group

group gruppiert Literale und/oder collectors, normalerweise um ein gemeinsames Set an Funktionen auf sie anzuwenden.

• name: Neuer gemeinsamer Name
• value: Neuer gemeinsamer Wert

{ kleinA: abc, kleinB: def }

<group name="GROSS">
  <data source="kleinA"/>
  <data source="kleinB"/>
  <postprocess>
    <case to="upper"/>
  </postprocess>
</group>

{ GROSS: ABC, GROSS: DEF }

choose

choose sendet nur einen Literal aus einer Gruppe weiter (mit abnehmender Priorität).

• name: Name des neuen Literals
• value: Wert des neuen Literals

{ wichtig: wichtig, vernachlässigbar: vernachlässigbar, unwichtig: unwichtig }

<data source="litA">
  <compose prefix="be" postfix="ung"/>
</data>

{ wichtig: wichtig }

range

range wertet zwei aufeinanderfolgende Literale als ganze Zahlen aus, die den Start- und Endpunkt einer Zahlenreihe definieren. Alle Zahlen dieser Reihe werden anschliessend als Literale ausgegeben.

• name (obligatorisch): Name der neuen Literale
• increment: Inkrement (Standard: 1)

{ anfang: 0, ende: 10 }

<range name="gerade zahl" increment="2">
  <data source="anfang"/>
  <data source="ende"/>
</range>

{ gerade zahl: 0, gerade zahl: 2, gerade zahl: 4, gerade zahl: 6, gerade zahl: 8, gerade zahl: 10 }

equalsFilter

equalsFilter gibt ein neues Literal aus, sofern die Werte der Literale alle gleich sind.

• name (obligatorisch): Name des neuen Literals
• value (obligatorisch): Wert des neuen Literals

{ litA: gleich, litA: gleich, litB: gleich }

<equalsFilter name="alle waren gleich" value="ja!">
  <data source="litA"/>
  <data source="litB"/>
</equalsFilter>

{ alle waren gleich: ja! }

all, any, none

all, any und none überprüfen, ob angegebenen Literale vorhanden sind. Sie geben standardmässig eine unbenannte (änderbar mit name=) Variable mit true als Wert (änderbar mit value=) aus, insofern die jeweilige Bedingung zutrifft:

• Bei all: Alle Literale sind im Datensatz vorhanden
• Bei any: Mindestens ein Literal ist im Datensatz vorhanden
• Bei none: Kein Literal ist im Datensatz vorhanden

{litB: wertB}

<all name="alle vorhanden">
  <data source="litA"/>
  <data source="litB"/>
</all>
<any name="einige vorhanden">
  <data source="litA"/>
  <data source="litB"/>
</any>
<none name="keine vorhanden">
  <data source="litA"/>
  <data source="litB"/>
</none>

{einige vorhanden: true}