use Herbaer::XMLDataWriter; # HASH-Daten einfach als XML ausgeben
$data = {
"kommissare" => [
{ "name" => "Thiel", "ort" => "Münster", },
{ "name" => "Ballauf", "ort" => "Köln", },
],
"fahrzeuge" => { "Thiel" => "Fahrrad", "Ballauf" => "Auto", },
"stand" => "aktuell",
"version" => "1",
};
$options = {
'@kommissare' => ["", "kommissar"],
'%fahrzeuge' => ["fahrzeug", "benutzt", '@kommissar'],
};
my $filepath_or_handle = "output.xml";
my $encoding = "utf-8";
my $namespace = "xml_tatort";
my $xslt = "transform.xslt";
my $xmlwriter = Herbaer::XMLDataWriter -> new ($options);
$xmlwriter -> open ($filepath_or_handle, $encoding, $namespace, $xslt);
$xmlwriter -> write ("tatort", {}, $data);
$xmlwriter -> close ();
$xmlwriter -> ignore ('^_');
$xmlwriter -> open ("erweitert.xml");
$xmlwriter -> open_element ("tatort");
$xmlwriter -> comment ("Hoffentlich verletze ich nicht die Rechte der ARD");
$xmlwriter -> write ("kommissare", {}, $data -> {"kommissare"});
$xmlwriter -> write (
"kommentar", {},
[ "Münster: genial komisch", "Köln: Schwäche ist menschlich", ]
);
$xmlwriter -> meta() -> {"author"} = "Herbär";
$xmlwriter -> write_meta ();
$xmlwriter -> close_element ("tatort");
$xmlwriter -> close ();
print STDERR $xmlwriter -> errormsg ();
Herbaer::XMLDataWriter erlaubt eine einfache Ausgabe einer HASH-Datenstruktur als XML-Dokument. Es ist nicht vorgesehen, eine bestimmte Reihenfolge festzulegen, in der die HASH-Einträge ausgegeben werden.
new ($options, $enc, $namespace, $xslt)$optionsHASH der Ausgabe-Einstellungen.
$encDie Voreinstellung der Kodierung (encoding) der Ausgabe. Der Default ist utf-8. Der Wert wirkt, wenn beim Aufruf von open der Parameter $enc nicht definiert ist.
$namespaceDer Vorgabewert für den XML-Namensraum, der mit dem öffnenden Tag des Wurzelelements ausgegeben wird. Der Wert wirkt, wenn beim Aufruf von open der Parameter $namespace nicht definiert ist.
$xsltDer Vorgabewert für den Verweis in der XSLT-Verarbeitungsanweisung. Der Wert wirkt, wenn beim Aufruf von open der Parameter $xslt nicht definiert ist. Der Wert "none" bedeutet, dass keine XSLT-Anweisung ausgegeben wird.
Die Funktion new (Konstruktor) ergibt einen neuen Kontext (Objekt) für die XML-Ausgabe. Die Parameter $enc, $namespace und $xslt sind lediglich Vorbelegungen für die entsprechenden Parameter beim Aufruf von open.
open ($path, $enc, $namespace, $xslt)$pathDer Dateipfad einer Ausgabedatei, die zu erstellen ist, oder ein geöffnetes Ausgabe-Handle oder "-" für die Ausgabe nach STDOUT. Der Vorgabe-Wert ist "-".
$encDie Kodierung (encoding) der Ausgabe. Wenn im Ausgabe-Kontext noch kein Vorgabewert definiert ist, wird $enc der neue Vorgabe-Wert.
$namespaceDer XML-Namensraum, der mit dem öffnenden Tag des Wurzelelements ausgegeben wird. Wenn noch kein Vorgabewert definiert ist (s. new), wird $namespace der Vorgabewert.
$xsltWenn $xslt nicht leer und nicht "none" ist, gibt die Funktion open eine XSLT-Verarbeitungsanweisung aus, die auf die URL $xslt verweist. Wenn noch kein Vorgabewert definiert ist, wird $xslt der neue Vorgabewert.
Alle Parameter sind optional.
Wenn $path ein Dateipfad ist, öffnet die Funktion open die Datei zur Ausgabe. Eine existierende Datei oder das Ziel eines symbolischen Verweises werden überschrieben. Das im Pfad angegebene Verzeichnis muss existieren.
Wenn ein Parameterwert leer oder nicht definiert ist, gilt der Vorgabewert des Ausgabe-Kontextes. Wenn im Ausgabe-Kontext kein Vorgabewert definiert ist, wird der übergebene Wert zum Vorgabewert für nachfolgende Aufrufe von open.
open speichert die Systemzeit unter dem Schlüssel date im HASH der Meta-Daten (s. meta). Wenn $path ein Dateipfad ist, wird auch $path unter dem Schlüssel file gespeichert.
write ($name, $attributes, $content)$nameEin Name, der die Ausgabe steuert. In der Regel ist $name der Name des Elements, das die Funktion write ausgibt.
$attributesHASH-Referenz der Attribute, die zum Element ausgegeben werden. Die Schlüssel sind die Attributnamen, die HASH-Werte die Attributwerte.
$contentDer Inhalt des auszugebenden Elements. $content kann eine HASH-Referenz, eine ARRAY-Referenz oder ein einfacher skalarer Wert sein. Die Ausgabe hängt wesentlich vom Referenz-Typ von $content ab.
Der HASH der Ausgabe-Einstellungen (Konstruktor new, Parameter $options) kann die Ausgabe der Funktion write steuern. Der Schlüssel der Ausgabe-Einstellung ist
%, wenn $content eine HASH-Referenz ist, |
@, wenn $content eine ARRAY-Referenz ist, |
$, wenn $content ein anderer skalarer Wert ist. |
Hier beschreibe ich die Ausgabe von write, wenn keine Ausgabe-Einstellung unter dem Schlüssel existiert.
Wenn $content eine HASH-Referenz ist, wird ein Element mit dem Namen $name und den Attributen $attributes ausgeben. Der Inhalt des Elements entsteht durch den Aufruf von $xmlwriter -> write ($k, undef, $v) für jedes Schlüssel/Wert-Paar ($k, $v) in $content.
$xmlwriter -> write (
"kommissar",
{"alter" => 43,},
{"name" => "Thiel", "ort" => "Münster"}
);gibt aus:
<kommissar alter="43"> <ort>Münster</ort> <name>Thiel</name> </kommissar>
Die Reihenfolge der Kindelemente kann abweichen.
Wenn $content eine ARRAY-Referenz ist, wird $xmlwriter -> write ($name, $attributes, $v) für jeden ARRAY-Eintrag $v aufgerufen.
$xmlwriter -> write (
"kommissar",
{"serie" => "Tatort",},
["Thiel", "Ballauf", "Schenk"]
);gibt aus:
<kommissar serie="Tatort">Thiel</kommissar> <kommissar serie="Tatort">Ballauf</kommissar> <kommissar serie="Tatort">Schenk</kommissar>
Wenn $content ein einfacher Wert ist, wird er als Inhalt eines $name-Elements ausgegeben. Zeichen, die eine besondere Bedeutung für XML haben, werden durch "character entities" ersetzt, auch in Attributwerten.
$xmlwriter -> write (
"titel",
{"kommissar" => "Thiel & Börne & \"Alberich\""},
"Dreimal schwarzer Kater & Mäuschen"
);gibt aus:
<titel kommissar="Thiel & Börne & "Alberich"">Dreimal schwarzer Kater & Mäuschen</titel>
close ()Schließt die noch geöffneten XML-Elemente und die Ausgabedatei, wenn an open oder new ein Dateipfad übergeben wurde. Wenn ein geöffnetes Ausgabe-Handle an open übergeben wurde, bleibt das Handle geöffnet.
write_meta ($attributes)Diese Hilfsfunktion gibt "Meta-Daten", die die Funktion open anlegt, aus. Sie erspart einen Teil des Schreibaufwandes für $xmlwriter -> write ("meta", $attributes, $xmlwriter -> meta ())
meta ()Der Rückgabewert ist die HASH-Referenz der Meta-Daten, die der Funktion open anlegt. Vor der Ausgabe der Meta-Daten können weiter Elemente in den HASH eingefügt werden.
$xmlwriter -> meta () -> {"author"} = "Herbär";
$xmlwriter -> write_meta ();
gibt etwa aus:
<meta> <date>2013-02-21T19:18:38</date> <file>XMLDataWriter.testout/04_details.xml</file> <author>Herbär</author> </meta>
Die Zeitangabe und der Dateipfad sind hier natürlich nur Beispiele.
ignore ($regex)Der reguläre Ausdruck $regex passt auf die Namen, die die Funktion write bei der Ausgabe ignoriert. Nach $xmlwriter -> ignore ("^_"); werden z.B. alle HASH-Einträge, deren Schlüssel mit _ beginnen, bei der Ausgabe ignoriert. Tatsächlich wird $regex mit dem Parameter $name der Funktion write abgeglichen.
Wenn $regex nicht definiert ist, wird der im Kontext gespeicherte reguläre Ausdruck gelöscht.
$xmlwriter -> write ("kommissar", {}, "Thiel");
$xmlwriter -> ignore ("^komm");
$xmlwriter -> write ("kommissar", {}, "Börne");
$xmlwriter -> ignore ();
$xmlwriter -> write ("kommissar", {}, "Schenk");
gibt aus:
<kommissar>Thiel</kommissar> <kommissar>Schenk</kommissar>
open_element ($eltname, $attributes)$eltnameDer Elementname des auszugebenden öffnenden "Tags".
$attributesHASH-Referenz der Attribute das auszugebenden Elements
Diese Funktion gibt das öffnende Tag des Elements mit dem Namen $eltname und den Attributen $attributes aus. Der Elementname wird der Liste der offenen Elemente hinzugefügt. Nach dem Aufruf $xmlwriter -> open_element ($eltname) sollte später der Aufruf $xmlwriter -> close_element ($eltname) folgen. Die Funktion write ruft intern open_element auf.
$xmlwriter -> open_element ("kommissar", {"name" => "Thiel", "ort" => "Münster",});gibt aus:
<kommissar ort="Münster" name="Thiel">
Die Reihenfolge der Attribute ist nicht festgelegt.
close_element ($eltname)Diese Funktion schreibt das schließende Tag des Elements mit dem Namen $eltname und entfernt den ersten Namen in der Liste der Namen der offenen Elemente. Wenn kein Element offen ist oder die beiden Namen nicht übereinstimmen, wird eine Fehlermeldung gespeichert (s. errormsg). close_element wird intern von write aufgerufen.
commment ($text)Diese Funktion gibt $text als Kommentar eingerückt in einer neuen Zeile aus und beendet nach dem Kommentar die Zeile. Die Zeichenfolge -- in $text wird durch -*- ersetzt.
errormsg ()Ergibt einen Text, der in jeder Zeile eine Fehlermeldung enthält. Die möglichen Fehlermeldungen sind:
out": systemmsgDie Datei out konnte nicht zur Ausgabe geöffnet werden (open). systemmsg ist die System-Fehlermeldung.
close_element eltclose_element ($elt) wurde aufgerufen, aber es ist kein XML-Element offen.
elt elclose_element ($elt)$elt = "elt", aufgerufen, aber das offenen Element ist el.
close_element eltBeim Aufruf von open_element mit dem Parameterwert elt ist das Ausgabe-HANDLE nicht geöffnet.
write nameBeim Aufruf von write mit dem Parameter $name = "name"elt ist das Ausgabe-HANDLE nicht geöffnet.
commentBeim Aufruf von comment ist das Ausgabe-HANDLE nicht geöffnet.
name valueDer Wert value der Option zur Ausgabe von HASH-Daten unter dem Schlüssel name ist weder eine ARRAY-Referenz noch der Wert IGNORE.
name valueDer Wert value der Option zur Ausgabe von ARRAY-Daten unter dem Schlüssel name ist weder eine ARRAY-Referenz noch der Wert IGNORE.
name typeDer Datentyp type zur Ausgabe eines einfachen Wertes unter dem Schlüssel name in der Funktion write ist nicht bekannt/ungültig.
Die Ausgabe-Einstellungen (new, Parameter $options) steuern die Ausgabe der Funktion write ($name, $attributes, $content)[ (allgemeine Einstellungen) wirken unabängig vom Wert des Parameters wort]$name (dem Schlüssel). Andere HASH-Schlüssel wirken nur für einen einzelnen Wert des Parameters $name. Diese HASH-Schlüssel sind aus einem Kennzeichen für den Referenz-Typ von $content und dem Parameter-Wert $name zusammengesetzt. Das Kennzeichen ist
% | $name ist eine HASH-Referenz |
@ | $name ist eine ARRAY-Referenz |
$ | sonst |
Ein logisch wahrer Wert bewirkt, dass zu einem leeren HASH ein XML-Element ausgegeben wird. Auch bei einem logisch wahren Wert erfolgt zu einem leeren HASH keine Ausgabe, wenn in der Einstellung zu dem jeweiligen Schlüssel ein leerer Wert statt des Namens des Elternelements angegeben ist. Auch für einzelne Schlüssel kann festgelegt werden, dass zu einem leeren HASH ein XML-Element ausgegeben wird.
use Herbaer::XMLDataWriter; # HASH-Daten als XML ausgeben
my $options = {};
my $xmlwriter = new Herbaer::XMLDataWriter ($options);
$xmlwriter -> open ("kommissare.xml");
# ...
my $att = { "reihe" => "Tatort" };
$xmlwriter -> write ("attribute", $att, {}); # keine Ausgabe
$options -> {"[empty_hash]"} = 1;
$options -> {'%attrib'} = [""];
$xmlwriter -> write ("attribute", $att, {});
$xmlwriter -> write ("attrib", $att, {}); # keine Ausgabe
$options -> {"[empty_hash]"} = 0;
$xmlwriter -> write ("attribute", $att, {}); # wieder keine Ausgabe
# ...
$xmlwriter -> close ();gibt aus:
<attribute reihe="Tatort"></attribute>
IGNOREDie Zeichenkette "IGNORE" als Wert bedeutet, dass keine Ausgabe erfolgt.
$xmlwriter -> write ("kommissar", {}, "Kopper");
$options -> {"[empty_hash"]} = 1;
$xmlwriter -> write ("kommissar", {}, "Kopper");
$xmlwriter -> write ("kommissar", {}, ["Odenthal", "Kopper",]);
$xmlwriter -> write ("set",
{"location" => "Münster"},
{"kommissar" => "Thiel", "assistent" => "Krusenstern"});
$options -> {'$kommissar'} = undef;
$xmlwriter -> write ("kommissar", {}, "Leitmaier");
$xmlwriter -> write ("kommissar", {}, ["Leitmaier", "Batic",]);gibt aus:
<set location="Münster"> <assistent>Krusenstern</assistent> </set> <kommissar>Leitmaier</kommissar> <kommissar>Leitmaier</kommissar> <kommissar>Batic</kommissar>
$xmlwriter -> write ("kommissar", {}, "Kopper"); gibt nichts aus, weil die Ausgabe einfacher Werte unter dem Schlüssel "kommissar" unterbunden ist. Die Anweisung $xmlwriter -> write ("kommissar", {}, ["Odenthal", "Kopper",]); ruft intern $xmlwriter -> write ("kommissar", {}, "Odenthal"); und $xmlwriter -> write ("kommissar", {}, "Kopper"); auf und gibt deshalb ebenfalls nichts aus.
$options -> {'@kommissar'} = "IGNORE";
$xmlwriter -> write ("kommissar", {}, "Kopper");
$xmlwriter -> write ("kommissar", {}, ["Odenthal", "Kopper",]);
$xmlwriter -> write ("set",
{"location" => "Köln"},
{"kommissar" => ["Ballauf", "Schenk",], "assistent" => "Friederike"});
$options -> {'@kommissar'} = undef;
$xmlwriter -> write ("kommissar", {}, ["Ritter", "Stark",]);gibt aus:
<kommissar>Kopper</kommissar> <set location="Köln"> <assistent>Friederike</assistent> </set> <kommissar>Ritter</kommissar> <kommissar>Stark</kommissar>
Das nächste Beispiel unterdrückt die Ausgabe von HASH-Daten.
$options -> {'%kommissar'} = "IGNORE";
$xmlwriter -> write ("kommissar", {}, {"name" => "Thiel", "ort" => "Münster",});
$options -> {'%kommissar'} = undef;
$xmlwriter -> write ("kommissar", {}, {"name" => "Lürsen", "ort" => "Bremen",});gibt aus:
<kommissar> <ort>Bremen</ort> <name>Lürsen</name> </kommissar>
Der Wert zur Steuerung der Ausgabe von HASH-Daten ist eine ARRAY-Referenz von bis zu vier Werten:
[$parent, $child, $key, "WRITE_EMPTY"]
Wenn der Wert keine ARRAY-Referenz und auch nicht die Zeichenkette IGNORE ist, wird ein Fehler gemeldet. Der Wert wird ingnoriert: die Ausgabe erfolgt so, als gäbe es keine Einstellung.
my $content = { "name" => "Thiel", "ort" => "Münster", };
my $att = { "sex" => "male" };
$xmlwriter -> write ("kommissar", $att, $content);
$options -> {'%kommissar'} = "krimi";
$xmlwriter -> write ("kommissar", $att, $content);
print STDERR $xmlwriter -> errormsg ();gibt aus:
<kommissar sex="male"> <ort>Münster</ort> <name>Thiel</name> </kommissar> <kommissar sex="male"> <ort>Münster</ort> <name>Thiel</name> </kommissar>
und schreibt nach STDERR:
UNKNOWN HASH OUTPUT OPTION kommissar krimi
$parent ist der Name des enthaltenden Elements.
$options -> {'%kommissar'} = ["ermittler"];
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<ermittler sex="male"> <ort>Münster</ort> <name>Thiel</name> </ermittler>
Wenn $parent nicht definiert oder leer ist, wird kein "umklammerndes" Element ausgegeben. Die Attribute werden in diesem Fall zu den einzelnen Einträgen des HASH ausgegeben.
$options -> {'%kommissar'} = [];
$xmlwriter -> write ("kommissar", $att, $content);
$options -> {'%kommissar'} = [''];
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<ort sex="male">Münster</ort> <name sex="male">Thiel</name> <ort sex="male">Münster</ort> <name sex="male">Thiel</name>
$child ist der Schlüssel, mit dem die Funktion write für jeden HASH-Eintrag aufgerufen wird.
$options -> {'%kommissar'} = ["ermittler", "detail"];
$xmlwriter -> write ("kommissar", $att, $content);
$options -> {'%kommissar'} = ['', "detail"];
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<ermittler sex="male"> <detail>Münster</detail> <detail>Thiel</detail> </ermittler> <detail sex="male">Münster</detail> <detail sex="male">Thiel</detail>
Der HASH-Schlüssel kann als Attributwert ausgegeben werden. Dazu ist als $key das Zeichen '@', gefolgt vom Namen das Attributs, anzugeben.
$options -> {'%kommissar'} = ["ermittler", "detail", '@key'];
$xmlwriter -> write ("kommissar", $att, $content);
$options -> {'%kommissar'} = ["", "detail", '@key'];
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<ermittler sex="male"> <detail key="ort">Münster</detail> <detail key="name">Thiel</detail> </ermittler> <detail sex="male" key="ort">Münster</detail> <detail sex="male" key="name">Thiel</detail>
Der HASH-Schlüssel wird in den HASH der Attribute eingetragen und nach der Ausgabe wieder gelöscht. Wenn der an write übergebene HASH der Attributwerte an die Aufrufe zur Ausgabe der HASH-Einträge übergeben wird, kann der HASH der Attribute geändert werden. Im folgenden Beispiel wird der Schlüssel "key" aus dem HASH der Attribute gelöscht.
$att = { "key" => "tatort" };
$options -> {'%kommissar'} = undef;
$xmlwriter -> write ("kommissar", $att, $content);
$options -> {'%kommissar'} = ["", "detail", '@key'];
$xmlwriter -> write ("kommissar", $att, $content);
$options -> {'%kommissar'} = undef;
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<kommissar key="tatort"> <ort>Münster</ort> <name>Thiel</name> </kommissar> <detail key="ort">Münster</detail> <detail key="name">Thiel</detail> <kommissar> <ort>Münster</ort> <name>Thiel</name> </kommissar>
Wenn der Wert des HASH-Eintrags selbst eine HASH-Referenz ist, kann der HASH-Schlüssel auch als HASH-Eintrag seines Wertes ausgegeben werden. $key ist in diesem Fall der Schlüssel, unter dem der HASH-Schlüssel in den verschachtelten HASH eingetragen wird. $key darf in diesem Fall nicht mit dem Zeichen '@' beginnen.
my $nestedhash = {
"Münster" => {
"kommissar" => "Thiele",
"assistent" => "Krusenstern",
},
"Köln" => {
"kommissar" => "Ballauf",
"assistent" => "Friederike",
}
};
$options -> {'%locations'} = ['', 'location', 'city'];
$xmlwriter -> write ('locations', undef, $nestedhash);
gibt aus:
<location> <city>Köln</city> <assistent>Friederike</assistent> <kommissar>Ballauf</kommissar> </location> <location> <city>Münster</city> <assistent>Krusenstern</assistent> <kommissar>Thiele</kommissar> </location>
Der Eintrag im verschachtelten HASH wird nach der Ausgabe wieder gelöscht. Ein HASH, den ein Eintrag eines auszugebenden HASH referenziert, kann geändert werden. Im folgenden Beispiel wird der Eintrag unter dem Schlüssel "city" erst überschrieben und dann gelöscht.
$nestedhash = {
"Köln" => {
"city" => "Kalk",
"kommissar" => "Ballauf",
"assistent" => "Friederike",
}
};
$options -> {'%locations'} = ['', 'set', '@city'];
$xmlwriter -> write ('locations', undef, $nestedhash);
$options -> {'%locations'} = ['', 'location', 'city'];
$xmlwriter -> write ('locations', undef, $nestedhash);
$options -> {'%locations'} = ['orte', 'location', '@city'];
$xmlwriter -> write ('locations', undef, $nestedhash);gibt aus:
<set city="Köln">
<city>Kalk</city>
<assistent>Friederike</assistent>
<kommissar>Ballauf</kommissar>
</set>
<location>
<city>Köln</city>
<assistent>Friederike</assistent>
<kommissar>Ballauf</kommissar>
</location>
<orte>
<location city="Köln">
<assistent>Friederike</assistent>
<kommissar>Ballauf</kommissar>
</location>
</orte>Wenn der Wert des HASH-Eintrags keine HASH-Referenz ist, bleibt ein Wert von $key, der nicht mit '@' beginnt, fast (s. unten) wirkungslos.
$options -> {'%set'} = ["", "detail", "key"];
$xmlwriter -> write ('set', undef,
{
"location" => "Münster",
"staff" => { "kommissar" => "Thiele", "medic" => "Börne" },
"krimis" => [ "Dreimal schwarzer Kater", "Der doppelte Lott", ],
}
);gibt aus:
<detail>Münster</detail> <detail> <medic>Börne</medic> <kommissar>Thiele</kommissar> <key>staff</key> </detail> <detail>Dreimal schwarzer Kater</detail> <detail>Der doppelte Lott</detail>
Wenn $child nicht definiert oder leer ist, hängt der zum Aufruf verwendete Schlüssel davon ab, ob $key definiert und nicht leer ist. Wenn $key definiert und nicht leer ist, gibt write den Parameter $name bei den Aufrufen für die einzelnen HASH-Einträge weiter.
$options -> {'%kommissar'} = ["ermittler", undef, '@key'];
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<ermittler> <kommissar key="ort">Münster</kommissar> <kommissar key="name">Thiel</kommissar> </ermittler>
Das gilt auch, wenn $key nicht mit '@' beginnt und deshalb nicht weiter wirkt:
$options -> {'%kommissar'} = ["ermittler", undef, 'key'];
$xmlwriter -> write ("kommissar", $att, $content);gibt aus:
<ermittler> <kommissar>Münster</kommissar> <kommissar>Thiel</kommissar> </ermittler>
In der Regel sind $child und $key beide definiert und nicht leer oder beide undefiniert.
Zu einem leeren HASH wird in der Regel kein XML-Element ausgegeben, wenn nicht die Einstellung [empty_hash] logisch wahr ist. Der Wert "WRITE_EMPTY" bewirkt, daß auch zu einem leeren HASH ein XML-Element ausgegeben wird. Der Name des XML-Elements ist $parent oder der Schlüssel, falls $parent nicht definiert oder leer ist.
$att = { "reihe" => "Tatort", "inhalt" => "leer" };
$options -> {'%kommissar'} = ["ermittler", undef, 'key', "WRITE_EMPTY"];
$xmlwriter -> write ("kommissar", $att, {});
$options -> {'%kommissar'} = ["", undef, 'key', "WRITE_EMPTY"];
$xmlwriter -> write ("kommissar", $att, {});gibt aus:
<ermittler reihe="Tatort" inhalt="leer"></ermittler> <kommissar reihe="Tatort" inhalt="leer"></kommissar>
Der Wert zur Steuerung der Ausgabe von ARRAY-Daten ist entweder der Wert IGNORE oder eine ARRAY-Referenz mit bis zu drei Werten
[$parent, $child, "WRITE_EMPTY"]
Wenn der Wert keine ARRAY-Referenz und auch nicht die Zeichenkette IGNORE ist, wird ein Fehler gemeldet. Der Wert wird ingnoriert: die Ausgabe erfolgt so, als gäbe es keine Einstellung.
$parent$parent ist der Name des umfassenden Elements. Wenn $parent nicht definiert oder leer ist, wird kein umfassendes Element ausgegeben. Die Attribute ($attributes) werden in diesem Fall zu den einzelen Elementen des ARRAY ausgegeben.
$child$child ist der Schlüssel, der beim Aufruf von write zur Ausgabe der einzelnen ARRAY-Elemente übergeben wird.
Wenn $child eine ARRAY-Referenz ist, dann werden die Elemente von $child nacheinander als Schlüssel zur Ausgabe der einzelnen ARRAY-Elemente an write übergeben. Das letzte Element von $child wird so oft wie nötig wiederholt.
Wenn $child nicht definiert oder leer ist, wird der Wert des Parameters $name verwendet.
"WRITE_EMPTY" möglich. Normalerweise werden leere ARRAYs nicht ausgegeben. Der Wert "WRITE_EMPTY" bewirkt, dass auch zu einem leeren ARRAY ein XML-Element ausgegeben wird. Wennmy $kommissare = ["Ballauf", "Schenk"];
$att = { "producer" => "WDR" };
$options -> {'@kommissar'} = [];
$xmlwriter -> write ("kommissar", $att, $kommissare);gibt aus:
<kommissar producer="WDR">Ballauf</kommissar> <kommissar producer="WDR">Schenk</kommissar>
$options -> {'@kommissar'} = [ "ermittler" ];
$xmlwriter -> write ("kommissar", $att, $kommissare);gibt aus:
<ermittler producer="WDR"> <kommissar>Ballauf</kommissar> <kommissar>Schenk</kommissar> </ermittler>
$options -> {'@kommissar'} = [ "", "ermittler" ];
$xmlwriter -> write ("kommissar", $att, $kommissare);gibt aus:
<ermittler producer="WDR">Ballauf</ermittler> <ermittler producer="WDR">Schenk</ermittler>
$options -> {'@kommissar'} = [ "mordkommission", "ermittler" ];
$xmlwriter -> write ("kommissar", $att, $kommissare);gibt aus:
<mordkommission producer="WDR"> <ermittler>Ballauf</ermittler> <ermittler>Schenk</ermittler> </mordkommission>
$options -> {'@kommissar'} = [ "mordkommission", ["leiter", "ermittler"] ];
$xmlwriter -> write ("kommissar", $att, $kommissare);gibt aus:
<mordkommission producer="WDR"> <leiter>Ballauf</leiter> <ermittler>Schenk</ermittler> </mordkommission>
$options -> {'@kommissar'} = ["", ["leiter", "ermittler"], "WRITE_EMPTY" ];
$xmlwriter -> write ("kommissar", $att, $kommissare);
$xmlwriter -> write ("kommissar", $att, []);gibt aus:
<leiter producer="WDR">Ballauf</leiter> <ermittler producer="WDR">Schenk</ermittler> <kommissar producer="WDR"></kommissar>
$options -> {'@kommissar'} = "krimi";
$xmlwriter -> write ("kommissar", $att, $kommissare);
print STDERR $xmlwriter -> errormsg ();gibt aus:
<kommissar producer="WDR">Ballauf</kommissar> <kommissar producer="WDR">Schenk</kommissar>
und gibt die Meldung UNKNOWN HASH OUTPUT OPTION kommissar krimi nach STDERR aus.
Der Wert zur Steuerung der Ausgabe von einfachen Werten ist
entweder der Wert IGNORE |
oder eine ARRAY-Referenz mit bis zu zwei Werten [. |
oder eine Zeichenkette $type anders als IGNORE. Die einfache Zeichenkette $type ist gleichbedeutend mit [undef, . |
$element ist der Name des auszugebenden Elements.
$att = { "series" => "Tatort" };
$options -> {'$kommissar'} = ["ermittler"];
$xmlwriter -> write ("kommissar", $att, "Börne");gibt aus:
<ermittler series="Tatort">Börne</ermittler>
Wenn $element nicht definiert oder leer ist, wird der Wert des Parameters $name als Elementname genommen.
$att = { "series" => "Tatort" };
$options -> {'$kommissar'} = [];
$xmlwriter -> write ("kommissar", $att, "Thiel");gibt aus:
<kommissar series="Tatort">Thiel</kommissar>
Die möglichen Werte für $type sind:
emptyEs wird ein leeres Element ausgegeben, wenn der als Parameter $content übergebene Wert definiert ist.
$options -> {'$kommissar'} = "empty";
$xmlwriter -> write ("kommissar", $att, "Börne");gibt aus:
<kommissar series="Tatort"/>
timeDie Systemzeit (ein ganzzahliger Wert) wird im Format YYYY-MM-HHThh:mm:ss
my $mordzeit = time ();
$xmlwriter -> write ("mordzeit", $att, $mordzeit);
$options -> {'$mordzeit'} = "time";
$xmlwriter -> write ("mordzeit", $att, $mordzeit);
$options -> {'$mordzeit'} = ["crimetime", "time"];
$xmlwriter -> write ("mordzeit", $att, $mordzeit);gibt aus (wenn Ihre Uhr passend gestellt ist):
<mordzeit series="Tatort">1362146565</mordzeit> <mordzeit series="Tatort">2013-03-01T15:02:45</mordzeit> <crimetime series="Tatort">2013-03-01T15:02:45</crimetime>
Andere Werte führen zu einer Fehlermeldung. Der Wert wird ausgegeben, als wäre $type nicht definiert.
$options -> {'$mordzeit'} = "Tatzeit";
$xmlwriter -> write ("mordzeit", $att, $mordzeit);
print STDERR $xmlwriter -> errormsg ();gibt aus:
<mordzeit series="Tatort">1362147587</mordzeit>
und gibt die Meldung UNKNOWN TYPE mordzeit Tatzeit an STDERR aus.
Der an write übergebene HASH der Attributwerte ($attributes) kann in bestimmten Fällen geändert werden, wenn $content eine HASH-Referenz ist.
Wenn der Parameter $content der Funktion write eine HASH-Referenz ist, kann ein HASH, den ein Eintrag von $content referenziert, geändert werden.