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
)$options
HASH der Ausgabe-Einstellungen.
$enc
Die 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.
$namespace
Der 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.
$xslt
Der 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
)$path
Der Dateipfad einer Ausgabedatei, die zu erstellen ist, oder ein geöffnetes Ausgabe-Handle oder "-" für die Ausgabe nach STDOUT. Der Vorgabe-Wert ist "-".
$enc
Die Kodierung (encoding
) der Ausgabe. Wenn im Ausgabe-Kontext noch kein Vorgabewert definiert ist, wird $enc
der neue Vorgabe-Wert.
$namespace
Der XML-Namensraum, der mit dem öffnenden Tag des Wurzelelements ausgegeben wird. Wenn noch kein Vorgabewert definiert ist (s. new
), wird $namespace
der Vorgabewert.
$xslt
Wenn $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
)$name
Ein Name, der die Ausgabe steuert. In der Regel ist $name
der Name des Elements, das die Funktion write
ausgibt.
$attributes
HASH-Referenz der Attribute, die zum Element ausgegeben werden. Die Schlüssel sind die Attributnamen, die HASH-Werte die Attributwerte.
$content
Der 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
)$eltname
Der Elementname des auszugebenden öffnenden "Tags".
$attributes
HASH-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
": systemmsg
Die Datei out
konnte nicht zur Ausgabe geöffnet werden (open
). systemmsg
ist die System-Fehlermeldung.
close_element
elt
close_element ($elt)
wurde aufgerufen, aber es ist kein XML-Element offen.
elt
el
wurde mit dem Wert close_element
($elt)$elt
= "elt
", aufgerufen, aber das offenen Element ist el
.
close_element
elt
Beim Aufruf von open_element
mit dem Parameterwert elt
ist das Ausgabe-HANDLE nicht geöffnet.
write
name
Beim Aufruf von write
mit dem Parameter $name
= "name
"elt
ist das Ausgabe-HANDLE nicht geöffnet.
comment
Beim Aufruf von comment
ist das Ausgabe-HANDLE nicht geöffnet.
name
value
Der Wert value
der Option zur Ausgabe von HASH-Daten unter dem Schlüssel name
ist weder eine ARRAY-Referenz noch der Wert IGNORE
.
name
value
Der Wert value
der Option zur Ausgabe von ARRAY-Daten unter dem Schlüssel name
ist weder eine ARRAY-Referenz noch der Wert IGNORE
.
name
type
Der 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
. HASH-Schlüssel der Form 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>
IGNORE
Die 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:
empty
Es 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"/>
time
Die Systemzeit (ein ganzzahliger Wert) wird im Format
ausgeben.YYYY
-MM
-HH
Thh
: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.