Standard-Funktionen


Table of Contents

1. Standard-Funktionen - standard.xsl
2. Zahlen und Rechnen - numbers.xsl
3. Interne Funktionen - internals.xsl
4. Strings und Texte - strings.xsl
5. Logging-System - internals.logging.xsl
6. Mathematische Funktionen - math.xsl
7. StyleCheck - internals.stylecheck.xsl
8. Meta-Funktionen - internals.meta.xsl
9. Testen von Stylesheets - internals.testing.xsl
10. Dateien und Dateisystem - files.xsl
11. Index
12. Inconsistencies Detected!
12.1. Top-level element problems

Import/include tree (in order of importance; reverse import order)

Available invocation parameters

Available specialization parameters

1. Standard-Funktionen - standard.xsl

Filename: standard.xsl

Import statements:

$Revision: 31 $, $Date: 2011-06-05 22:45:26 +0200 (Sun, 05 Jun 2011) $

Die XSLT-Standard-Bibliothek (XSLT-SB) beinhaltet nützliche, immer wieder gebrauchte Funktionen und Templates. Gleichzeitig dient sie als beispielhafte Inplementierung bestimmter Techniken. Sie wendet sich als Beispielsammlung vor allem an deutschsprachige Entwickler, um für diese die Einstiegshürden zu senken.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Benutzung

Die Stylesheets der XSLT-SB können per xsl:import bzw. xsl:include direkt in eigene Stylesheets eingebunden werden. Die meisten Stylesheets binden weitere Stylesheets ein. Die Import-Hierarchie (und damit eine Liste der jeweils benötigten Stylesheets) wird am Anfang der HTML-Dokumentation (unter »Import/include tree«) ausgegeben. So kann man beispielsweise in math.html nachlesen, dass internals.xsl, internals.logging.xsl und strings.xsl benötigt werden. (Saxon beschwert sich ab Version 9.3 über das mehrfache Einbinden von Stylesheets, dies ist aber kein Fehler, sondern ein ignorierbarer Hinweis.)

Die Test-Stylesheets (z.B. »math_tests.xsl«) werden zum Einsatz der Bibliothek nicht benötigt.

Allgemeines

Die Stylesheets folgen dem Paradigma von "Convention over Configuration", d.h. soweit sinnvoll, wird mit Voreinstellungen gearbeitet, die aber übeschrieben werden können.

Ungültige Eingaben werden soweit wie möglich abgefangen und – unter Ausgabe einer Warnung – durch sinnvolle Werte ersetzt. Diese Warnung kann abgeschaltet werden, das muss aber explizit erfolgen.

Per Standard werden dafür folgende Fehlerlevel verwendet:

  • WARN: Falsche Parameterwerte, ungültige Eingabewerte, es konnte zur Fehlerbehebung ein Standardwert zurückgegeben werden
  • ERROR: falsche Benutzung der XSLT-SB, Programmierfehler: in der Regel Abbruch der Verarbeitung
  • FATAL (sofortiger Abbruch der Verarbeitung): a) Fehler hat eventuell externe Auswirkungen/Seiteneffekte, z.B. falsche Ermittlung eines Dateinamens, b) Fataler Fehler innerhalb der XSLT-SB

Diese Bibliothek ist "work in progress". Templates und Funktionen entstehen nicht systematisch, sondern nach Bedarf. Entsprechend ihrer Reife werden sie mit einem der Stati "alpha", "beta", "mature" versehen. Dabei werden folgende Kriterien zu Grunde gelegt:

  • alpha: Tests erfolgreich mit Saxon
  • beta: Tests erfolgreich mit Saxon sowie AltovaXML oder Intel, außerdem haben alle aufgerufenen Funktionen/Templates den Status "beta"
  • mature: Funktion bzw. Template ist seit mindestens einem Jahr Teil der Bibliothek und alle benutzen Funktionen/Templates haben den Status "mature"

Produktiv sollten nur mit "mature" gekennzeichnete Funktionen und Templates eingesetzt werden.

Namenskonventionen

Es werden zwei Namespaces verwendet: http://www.expedimentum.org/XSLT/SB mit dem Präfix xsb: und http://www.expedimentum.org/XSLT/SB/intern mit dem Präfix intern:. Daneben kommen für spezielle Funktionen (wie der Aufruf von Java oder saxon-spezifischen Funktionen) weitere Namespaces zum Einsatz. Generell gilt: Funktionen und Templates, die ausschließlich zum internen Gebrauch innerhalb der XSLT-SB gedacht sind, haben das Präfix intern:, alle anderen das Präfix xsb:. Natürlich gibt es immer einen Graubereich, so dass sich sicher leicht Inkonsistenzen finden lassen.

Für Templates, Funktionen, Parameter und Variablen werden möglichst sprechende Namen gewählt, möglichst in Anlehnung an XPath und XSLT.

Templates werden in Klassennotation bezeichnet. Der lokale Template-Name beginnt mit einem Großbuchstaben, z.B. "intern:internals.logging.Output"

Funktionen werden durchgekoppelt mit Kleinbuchstaben bezeichnet, z.B. "xsb:roman-numeral-to-integer()".

Stylesheet-Parameter (mit globaler Gültigkeit) werden in Klassennotation bezeichnet. Der lokale Name beginnt mit einem Kleinbuchstaben, z.B. "$internals.logging.output-target". Sie sind in keinem Namespace. Stylesheet-Parameter werden jeweils nur einmal definiert, und zwar in dem Stylesheet, das in der Import-Hierarchie die niedrigste Priorität hat.

Variablen, die von einem Parameter abgeleitet werden, beginnen mit einem Unterstrich, z.B. "$_internals.logging.write-to-console".

Lokale Variablen werden mit einem kurzen, sprechenden Namen bezeichnet, z.B. "$temp".

Getunnelte Parameter werden mit der Endung ".tunneld" versehen, z.B. "$log-entry.write-to-console.tunneld".

Getunnelte Parameter werden im empfangenden Stylesheet deklariert.

Typung

Ergebnisse von Funktionen und Templates werden – soweit möglich – getypt. Die Rückgabe einer empty sequence wird vermieden, vielmehr werden dem Typ entsprechend 0, Leerstring o.ä. zurückgegeben.

An Funktionen oder Templates übergebene Parameter sollen – soweit möglich – empty sequences als Eingabe akzeptieren, um eine einfache Benutzbarkeit zu erreichen.

Tests

Templates und Funktionen werden – soweit möglich – getestet. Dazu gibt es am Ende jeden Stylesheets Test-Abschnitte oder externe Test-Stylesheets (nach dem Namensschema xxxxx_tests.xsl).

Die Tests haben zwei Aufgaben: einerseits weisen sie das richtige Funktionieren der Templates/Funktionen nach, andererseits stellen sie bei späteren Änderungen an den Templates/Funktionen sicher, das die ursprüngliche Funktionalität nicht geändert wird.

Daraus folgt, das bestehende Tests nicht nachträglich geändert, sondern nur ergänzt werden dürfen.

Jede Funktion wird mindestens pro Argument mit einem erwartetem Positiv-/true()-Wert, einem erwarteten Negativ-/false()-Wert, einem Leerstring/0-Wert und der empty sequence getestet.

Bei jeder Stylesheet-Datei werden die Tests in einem Template mit dem Namen intern:${Dateiname_ohne_Erweiterung}.self-test zusammengefasst.

Dokumentation

Alle Funktionen und Templates sowie deren Parameter werden – soweit sinnvoll – dokumentiert. Die Dokumentation umfasst eine kurze Beschreibung der Funktionalität und eventueller Parameter.

Zur Dokumentation wird XSLStyle™ mit DocBook verwendet. Hinweise zur Installation und Bedienung finden sich u.a. auf blog.expedimentum.com.

Zu jeder Funktion und jedem Template muss es in der Dokumentation ein para-Element mit einem xml:id-Attribut geben, dessen Wert der lokale Name der Funktion ist. XSLStyle™ erzeugt daraus in der HTML-Dokumentation Anker, so dass die Funktions-/Template-Beschreibungen direkt von außen verlinkt werden können.

Entwicklungsumgebung

Die XSLT-SB wurde mit OxygenXML entwickelt. Im Verzeichnis tools liegt die passende XPR-(Projekt-)Datei. Natürlich können die Stylesheets selbst aber in jeder beliebigen XSLT-2.0-Umgebung eingesetzt werden.

Zur XSLT-SB gehört eine build.xml für Apache Ant. Dieses Skript führt Routineaufgaben wie die Erstellung der Dokumentation, den Selbsttest der Stylesheets mit unterschiedlichen XSLT-Prozessoren und das Zippen von Distributionen für den Download durch. Außerdem können externe Tools wie Saxon-HE oder XSLStyle™ installiert werden. Wie unter Ant üblich können die verfügbaren Targets (Befehle) mit ant -p angezeigt werden. Für nahezu alle Targets sind zusätzliche Programme nötig, die einmalig mit ant get_tools installiert werden müssen. Falls auch mit AltovaXML getestet werden soll, muss dieses von Hand installiert und der Pfad in build.xml eingetragen werden.

Für die Benutzung der XSLT-SB ist Ant aber nicht notwendig, die Stylesheets können direkt in eigene Projekte eingebunden werden.

Schließlich gibt es mit tools/google_code.xsl ein Hilfs-Stylesheet zur Erstellung von Seiten für das Google-Code-Wiki.

Lizenz (duale Lizenzierung)

Die XSLT-SB und alle dazugehörigen Stylesheets und Dokumentationen sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Die XSLT-SB und alle dazugehörigen Stylesheets und Dokumentationen sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Sie dürfen – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Der verbindliche Lizenztext:

Copyright (c) 2009-2011 Stefan Krause

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Von dieser Lizenzierung ausgenommen sind Software, Stylesheets und andere Werke Dritter, die zum Erzeugen und Ausführen der XSLT eventuell notwendig, aber nicht Bestandteil der Distribution sind.

Revision History
Revision 0.2.312011-06-05Stf
Tests ausgelagert
Revision 0.2.302011-06-05Stf
Dokumentation ergänzt
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.532009-10-25Stf
Umstellung auf Namespaces xsb: und intern:
Revision 0.362009-08-02Stf
Umstellung der Lizenz auf CC-BY 3.0
Revision 0.262009-05-03Stf
erste Version mit Dokumentation

2. Zahlen und Rechnen - numbers.xsl

Path: numbers.xsl

Import statement:

$Revision: 36 $, $Date: 2011-06-24 00:45:29 +0200 (Fri, 24 Jun 2011) $

Dieses Stylesheet enthält Funktionen rund um Zahlen und Rechenoperationen.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.502015-05-27Stf
numbers_tests.xsl aus numbers.xsl ausgegliedert, neue Funktion: xsb:hex-to-integer()
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.532009-10-25Stf
Umstellung auf Namespaces xsb: und intern:
Revision 0.502009-10-11Stf
Start mit Testroutinen
Revision 0.362009-08-02Stf
Umstellung der Lizenz auf CC-BY 3.0
Revision 0.292009-05-03Stf
initiale Version

xsb:is-roman-numeral(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob der angegebene String eine römische Zahl ist.

Revision History
Revision 0.292009-05-03Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

xsb:roman-numeral-to-integer(1) as="xs:integer" (xsl:function)

Diese Funktion wandelt eine römische Zahl in einen Integer-Wert um. Ist der eingegebene Wert keine römische Zahl oder leer, ist das Ergebnis 0. Die Funktion ist nicht case-sensitiv, d.h. Groß-/Kleinschreibung der Eingabe spielt keine Rolle.

Revision History
Revision 0.292009-05-03Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

römische Zahl (String)

xsb:roman-number-char-to-integer(1) as="xs:integer" (xsl:function)

Diese Funktion wandelt eine römische Ziffer (eines der Zeichen I, V, X, L, C, D, M) in einen Integer-Wert um. Ist das eingegebene Zeichen keine römische Ziffer oder leer, ist das Ergebnis 0. Die Funktion ist nicht case-sensitiv, d.h. Groß-/Kleinschreibung der Eingabe spielt keine Rolle.

Revision History
Revision 0.292009-05-03Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

römische Ziffer (String)

xsb:force-cast-to-decimal(2) as="xs:decimal" (xsl:function)

Diese Funktion erzwingt die Umwandlung eines Strings in xs:decimal.

Ein gültiger String wird mit xs:decimal() umgewandelt. Die Eingabe einer Leersequenz, eines Leerstring oder eines ungültigen Strings ergibt 0.

Revision History
Revision 0.2.342011-06-26Stf

Status: beta

saubere Typung auf xs:decimal ergänzt

Revision 0.1142010-07-17Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

zu castender String

Parameter warn-if-wrong-input as="xs:boolean"

(Boolean) Erzeugt eine Fehlermeldung, wenn der eingegebenen String keine gültige xs:decimal-Zahl ist.

xsb:force-cast-to-decimal(1) as="xs:decimal" (xsl:function)

Shortcut für xsb:force-cast-to-decimal($input, true() )

Revision History
Revision 0.1142010-07-17Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

zu castender String

xsb:force-cast-to-integer(2) as="xs:integer" (xsl:function)

Diese Funktion erzwingt die Umwandlung eines Strings in xs:integer.

Ein gültiger String wird mit xsb:force-cast-to-integer() umgewandelt. Die Eingabe einer Leersequenz, eines Leerstring oder eines ungültigen Strings ergibt 0.

Revision History
Revision 0.1142010-07-17Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

zu castender String

Parameter warn-if-wrong-input as="xs:boolean"

(Boolean) Erzeugt eine Fehlermeldung, wenn der eingegebenen String keine gültige xs:integer-Zahl ist.

xsb:force-cast-to-integer(1) as="xs:integer" (xsl:function)

Shortcut für xsb:force-cast-to-integer($input, true() )

Revision History
Revision 0.1142010-07-17Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

zu castender String

xsb:hex-to-integer(1) as="xs:integer" (xsl:function)

wandelt Hexadezimal- in Integer-Zahlen um.

Whitespace in der Eingabe wird entfernt, damit Notationen wie »ff d8 d2 e9« ohne weitere Bearbeitung konvertiert werden können.

Die Eingabe eines Leerstrings, einer Leersequenz, eines oder mehrerer ungültiger Zeichen führt zu einer Fehlermeldung.

Eine andere Version dieser Funktion, die negative Zahlen als Zweierkomplement behandelt, findet sich in math.xsl

Beispiele

  • xsb:hex-to-integer('0') ergibt »0«

  • xsb:hex-to-integer('a') ergibt »10«

  • xsb:hex-to-integer('FFFF') ergibt »65535«

  • xsb:hex-to-integer('-29a') ergibt »-666«

Revision History
Revision 0.2.502012-05-19Stf

Status: beta

initiale Version

Parameter input as="xs:string"

eine hexadezimale Zahl (beliebige Folge aus 0-9 und A-F bzw. a-f), ggfs. mit einem vorangestellten »-« (Minus) für negative Zahlen

3. Interne Funktionen - internals.xsl

Path: internals.xsl

Import statements:

$Revision: 41 $, $Date: 2012-03-24 21:59:50 +0100 (Sa, 24 Mrz 2012) $

Dieses Stylesheet enthält interne Templates und Funktionen, z.B. für Logging und Debug-Meldungen.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.252011-05-29Stf
xsb:type-annotation und xsb:cast hinzugefügt.
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.822010-04-02Stf
Auslagerung von Test-Logik nach internals.testing.xsl und der Tests für internals.xsl und strings.xsl
Revision 0.532009-10-25Stf
Umstellung auf Namespaces xsb: und intern:
Revision 0.502009-10-11Stf
Ausgliederung von Logging aus internals.xsl nach internals.logging.xml; Eingliederung von strings-2.xsl
Revision 0.362009-08-02Stf
initiale Version

internals.logging-level as="xs:string" (xsl:param)

gültige Werte: »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL«

Meldungen können einen Level entsprechend den Log4j-Stufen »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« haben (siehe Template xsb:internals.Error). Dieser Parameter bestimmt, ab welchem Wert Meldungen geloggt (d.h. angezeigt bzw. ausgegeben) werden.

_internals.logging-level as="xs:integer" select="xsb:logging-level($internals.logging-level)" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

internals.errors.die-on-critical-errors as="xs:string" (xsl:param)

gültige Werte: »ja«, »nein«, »yes«, »no«, »0«, »1« und andere verbale Wahrheitswerte, die xsb:parse-string-to-boolean() versteht

Fehlermeldungen können einen Level entsprechend den Log4j-Stufen »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« haben (siehe Template xsb:internals.Error). Bei »ERROR« wird die Verarbeitung normalerweise sofort beendet. Ist aber dieser Parameter auf »No« gesetzt, wird die Verarbeitung fortgesetzt, z.B. für Debugging. Bei »FATAL« wird die Verarbeitung in jedem Fall abgebrochen.

_internals.errors.die-on-critical-errors as="xs:boolean" select="xsb:parse-string-to-boolean($internals.errors.die-on-critical-errors)" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

internals.logging.output-target as="xs:string?" (xsl:param)

gültige Werte: »console«, »file« oder »both«

Loggingmeldungen können via xsl:message auf die Konsole ausgegeben oder in die Ergebnis-Datei geschrieben werden. Auch beides ist möglich. Entsprechend ist als Ziel »console«, »file« oder »both« zu wählen. Bei einer davon abweichenden Eingabe wird nur auf die Konsole geschrieben

_internals.logging.write-to-console as="xs:boolean" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird. Bei der Ermittlung dieser Variablen wird außerdem der Parameter internals.logging.output-target auf Gültigkeit geprüft.

_internals.logging.write-to-file as="xs:boolean" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

internals.logging.write-to-file-style as="xs:string?" (xsl:param)

gültige Werte: »comment«, »element«, »html«, »text«

Nur bei Ausgabe in Datei: Loggingmeldungen können als HTML, XML-Elemente, Kommentare oder Text in das Ausgabedokument geschrieben werden. HTML eignet sich für die sofortige Anzeige, XML-Elemente für eine spätere maschinelle Auswertung, Kommentare für ad-hoc-Meldungen zur späteren Durchsicht. Text bietet sich an, wenn eine reine Report-Datei generiert werden soll. Ist die Eingabe ungültig, wird als Kommentar ausgegeben.

_internals.logging.write-to-file-as-comment as="xs:boolean" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird. Bei der Ermittlung dieser Variablen wird außerdem der Parameter internals.logging.write-to-file-style auf Gültigkeit geprüft.

_internals.logging.write-to-file-as-element as="xs:boolean" select="xsb:lax-string-compare($internals.logging.write-to-file-style, 'element')" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

_internals.logging.write-to-file-as-html as="xs:boolean" select="xsb:lax-string-compare($internals.logging.write-to-file-style, 'html')" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

_internals.logging.write-to-file-as-text as="xs:boolean" select="xsb:lax-string-compare($internals.logging.write-to-file-style, 'text')" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

internals.logging.linebreak-string as="xs:string?" xml:space="preserve" (xsl:param)

Dieses Zeichen wird bei Textausgabe als Zeilenwechsel ausgegeben, per Default 


_internals.root-node as="document-node()" select="/" (xsl:variable)

Dokumentenknoten. Hilfsvariable, um einen Kontext in kontextlose Funktionen und Templates zu transportieren.

xsb:internals.Logging (xsl:template)

Dieses Template ist ein Wrapper für intern:internals.logging.Output für ein einfaches Logging.

Viele Template-Parameter sind mit den Werten der Stylesheet-Parameter oder mit Werten von XPath-Funktionen vorbelegt, um die Benutzung zu vereinfachen.

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.preText as="xs:string?" required="no"

Parameter log-entry.ID as="xs:string?" required="no"

Parameter log-entry.timeStamp as="xs:dateTime?" required="no"

Parameter log-entry.processedFile as="xs:string?" required="no"

Parameter log-entry.level as="xs:string?" required="no"

Parameter log-entry.text as="xs:string?" required="no"

Parameter log-entry.category as="xs:string?" required="no"

Parameter log-entry.postText as="xs:string?" required="no"

Parameter log-entry.linebreak-string as="xs:string?" required="no"

Parameter log-entry.write-to-console as="xs:boolean" required="no"

Parameter log-entry.write-to-file as="xs:boolean" required="no"

Parameter log-entry.write-to-file-as-comment as="xs:boolean" required="no"

Parameter log-entry.write-to-file-as-element as="xs:boolean" required="no"

Parameter log-entry.write-to-file-as-html as="xs:boolean" required="no"

Parameter log-entry.write-to-file-as-text as="xs:boolean" required="no"

Parameter log-entry.write-preText as="xs:boolean" required="no"

Parameter log-entry.write-ID as="xs:boolean" required="no"

Parameter log-entry.write-timeStamp as="xs:boolean" required="no"

Parameter log-entry.write-processedFile as="xs:boolean" required="no"

Parameter log-entry.write-level as="xs:boolean" required="no"

Parameter log-entry.write-text as="xs:boolean" required="no"

Parameter log-entry.write-category as="xs:boolean" required="no"

Parameter log-entry.write-postText as="xs:boolean" required="no"

xsb:internals.Error (xsl:template)

Dieses Template gibt eine einfache Fehlermeldung aus. Ausgabeart und -ziel werden über die Stylesheet-Parameter bestimmt, wenn keine expliziten Einstellungen übergeben werden.

Es ist ein Wrapper mit sinvollen Vorgabewerten für das Template xsb:internals.Logging.

Außerdem sorgt es dafür, dass bei Fehlern der Stufen ERROR (wenn mit $internals.errors.die-on-critical-errors erlaubt) und FATAL die Verarbeitung des Stylesheets abgebrochen wird.

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter message as="xs:string?" required="no"

Fehlermeldung

Parameter level as="xs:string?" required="no"

Level der Fehlermeldung. In Anlehnung an Log4j werden per Vorgabe die Stufen »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« (in aufsteigender Reihenfolge der Dringlichkeit) verwendet.

Default: »ALL«.

Parameter caller as="xs:string?" required="no"

Aufrufende(s) Funktion/Template, z.B. xsb:get-context-as-string()

Parameter show-context as="xs:boolean" required="no"

Falls true(), wird zum Kontextkonten der Kontext angezeigt. Achtung! Das schlägt fehl, wenn es keinen Kontextknoten gibt, z.B. innerhalb von Funktionen oder innerhalb von xsl:for-each-Schleifen über dokumentenexterne Sequenzen. Deshalb gibt es auch ein Template xsb:internals.FunctionError, das dieses Problem umgeht.

Parameter write-to-file as="xs:boolean" required="no"

Falls true(), wird die Ausgabe in die Datei geschrieben. Standardwert: $_internals.logging.write-to-file. In bestimmten Umgebungen, z.B. innerhalb einer Funktion, darf das Template keinen Rückgabewert liefern (siehe deshalb auch xsb:internals.FunctionError). Über diesen Parameter kan der stylesheet-weite Standardwert überschrieben werden.

xsb:internals.FunctionError (xsl:template)

Dieses Template gibt eine einfache Fehlermeldung aus. Es ist ein Wrapper für xsb:internals.Error, der die Rückgabe von Werten durch das Template unterbindet (was innerhalb von Funktionen in der Regel unerwünscht ist und ggfs. zu Fehlern führen kann).

Achtung! Dadurch werden keine Meldungen (als Kommentar, Text, HTML, XML) in Ausgabedateien geschrieben!

Revision History
Revision 0.592009-10-26Stf

Status: beta

initiale Version

Parameter message as="xs:string?" required="no"

Fehlermeldung

Parameter level as="xs:string?" required="no"

Level der Fehlermeldung. In Anlehnung an Log4j werden per Vorgabe die Stufen »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« (in aufsteigender Reihenfolge der Dringlichkeit) verwendet.

Default: »ALL«.

Parameter caller as="xs:string?" required="no"

Aufrufende(s) Funktion/Template, z.B. xsb:get-context-as-string()

intern:internals.FatalError (xsl:template)

Dieses Template gibt eine Fehlermeldung bei Fehlern in der Logik der XSL-SB aus. Da das Ausführungsverhalten in solchen Situationen nicht vorhersehbar ist, wird die Verarbeitung abgebrochen.

Dieses Template ist ein Wrapper für xsb:internals.Error, der die Rückgabe von Werten durch das Template unterbindet (was innerhalb von Funktionen in der Regel unerwünscht ist und ggfs. zu Fehlern führen kann).

Achtung! Dadurch werden keine Meldungen (als Kommentar, Text, HTML, XML) in Ausgabedateien geschrieben!

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

initiale Version

Parameter errorID as="xs:string?" required="yes"

Fehler-Codenummer

Parameter caller as="xs:string?" required="yes"

Aufrufende(s) Funktion/Template, z.B. xsb:get-context-as-string()

xsb:internals.MakeHeader (xsl:template)

Dieses Template erzeugt bei der Ausgabe in eine Datei den Dateikopf, z.B. das Wurzelelement in XML oder Wurzel und Head in HTML.

Genaugenommen verteilt das Template nur entsprechend des Ausgabeformates auf Untertemplates wie intern:internals.logging.MakeHeader.element und intern:internals.logging.MakeHeader.html.

Revision History
Revision 0.1392011-04-24Stf

Status: alpha

initiale Version

xsb:internals.MakeFooter (xsl:template)

Dieses Template erzeugt bei der Ausgabe in eine Datei den Fuß, z.B. das schließende HTML-Tag oder XML-Element.

Genaugenommen verteilt das Template nur entsprechend des Ausgabeformates auf Untertemplates wie intern:internals.logging.MakeFooter.element und intern:internals.logging.MakeFooter.html.

Hook: kann zum Umformatieren überschrieben werden.

Revision History
Revision 0.1392011-04-24Stf

Status: alpha

initiale Version

xsb:internals.Log-system-properties (xsl:template)

Dieses Template gibt die Werte der Funktion system-property() für die im XSLT-Standard vorgegebenen Parameter vgl. http://www.w3.org/TR/xslt20/#function-system-property aus.

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter logging-level as="xs:string" required="no"

intern:internals.ProvisionalError (xsl:template)

Zu Beginn der Verarbeitung von internals.xsl (und damit von allen Stylesheets, die internals.xsl einbinden), sind ein paar Parameter für das Logging noch nicht gesetzt. Um trotzdem eine Fehlermeldung zu ermöglichen (beispielsweise bei der Prüfung von Stylesheet-Parametern), wird im diesen Template eine Fehlermeldung unter Verzicht aus betroffene Parameter auf der Konsole ausgegeben.

Das Template ist ein Wrapper für das Template xsb:internals.Logging und hat die selbe Signatur wie xsb:internals.Error.

Achtung! Im Unterschied zu xsb:internals.Error wird bei ERROR in jedem Fall abgebrochen, d.h. der Parameter $internals.errors.die-on-critical-errors beinflusst dieses Template nicht.

Revision History
Revision 0.602009-11-01Stf

Status: beta

initiale Version

Parameter message as="xs:string?" required="no"

Parameter level as="xs:string?" required="no"

Parameter caller as="xs:string?" required="no"

Parameter show-context as="xs:boolean" required="no"

Parameter write-to-file as="xs:boolean" required="no"

siehe xsb:internals.Error

Achtung! Dieser Parameter wird nur empfangen, um die Signatur von xsb:internals.Error zu erhalten, er wird aber nicht ausgewertet, d.h. es wird nie in die Ausgabedatei geschrieben.

intern:render-context-and-parent-as-string(1) as="xs:string" (xsl:function)

Diese Funktion erzeugt aus dem Kontext eines Knotens und dessen Elternknoten einen String in Form eines XPath-Ausdruckes, der diesen Knoten beschreibt. Kann z.B. zur Erläuterung bei Fehlermeldungen eingesetzt werden.

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter context as="node()?"

Kontextknoten vom Typ node(), kann also vom Typ element(), attribute(), text(), comment() usw. sein

xsb:render-context-as-string(1) as="xs:string" (xsl:function)

Diese Funktion erzeugt aus dem Kontext eines Knotens einen String in Form eines XPath-Ausdruckes, der diesen Knoten beschreibt. Kann z.B. zur Erläuterung bei Fehlermeldungen eingesetzt werden.

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter context as="node()?"

Kontextknoten vom Typ node(), kann also vom Typ element(), attribute(), text(), comment() usw. sein

xsb:parse-string-to-boolean(2) as="xs:boolean" (xsl:function)

Diese Funktion wandelt eine String-Eingabe in einen Boolean-Wert um. Sie kennt dabei mehr Begriffe als boolean(), z.B. »ja«/»nein«.

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

Parameter warn-if-wrong-input as="xs:boolean"

(Boolean) Erzeugt eine Fehlermeldung, wenn der eingegebene String nicht in der Liste der gültigen Werte enthalten ist.

xsb:parse-string-to-boolean(1) as="xs:boolean" (xsl:function)

Shortcut für xsb:parse-string-to-boolean($input, true()).

Revision History
Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

intern:render-level-to-pretext(1) as="xs:string" (xsl:function)

Erzeugt zu den verbalen Fehlerwerten »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« einen String, der bei xsb:internals.Error und verwandten Templates als preText verwendet werden kann.

Wird ein ungültiger Wert übergeben, wird der Wert für ALL gewählt.

Revision History
Revision 0.602009-11-01Stf

Status: beta

initiale Version

Parameter level as="xs:string?"

Eingabe (String)

xsb:is(2) as="xs:boolean" (xsl:function)

Diese Funktion vergleicht zwei beliebig getypte Werte und gibt bei Idendität true() zurück, d.h. der Vergleich ist eine Kombination aus eq und deep-equal() mit höherer Empfindlichkeit und einigen Sonderfällen.

Im Unterschied zum XPath-Operator is können auch atomic values verglichen werden.

Sind die Eingabewerte nicht vom gleichen Typ, ist das Ergebnis false().

Werden -0.0e0 und +0.0e0 verglichen, und unterstützt der jeweilie Typ diesen Unterschied, ist das Ergebnis false().

Werden NaN und NaN verglichen, ist das Ergebnis true().

Werden zwei Leersequenzen verglichen, ist das Ergebnis true().

Revision History
Revision 0.2.372011-06-26Stf

Status: alpha

Bugfix für "NaN" unter AltovaXML (bis einschließlich 2011 sp 3) eingefügt

Revision 0.2.342011-06-26Stf

Status: alpha

Unterscheidung von -0.0e0 und +0.0e0 eingefügt

Revision 0.1392011-04-24Stf

Status: alpha

explizite Behandlung für Leersequenzen eingefügt

Revision 0.612009-11-16Stf

Status: beta

initiale Version

Parameter input1

Eingabe (ohne Typ)

Parameter input2

Eingabe (ohne Typ)

xsb:node-kind(2) as="xs:string" (xsl:function)

Diese Funktion ermittelt die Art eines node(), d.h. sie gibt je nach übergebenen Knoten einen der Werte »document-node«, »element«, »attribute«, »text«, »comment«, »processing-instruction« oder »namespace« zurück. Schlagen all Versuche zur Ermittlung fehl, wird der Wert #undefined zurückgegeben (Mir ist kein entsprechender Input-node() bekannt).

Diese Funktion ist eine Implementierung des dm:node-kind-Accessors aus dem XQuery 1.0 and XPath 2.0 Data Model (XDM).

Revision History
Revision 0.612009-11-16Stf

Status: beta

initiale Version

Parameter context as="node()?"

Eingabeknoten

Parameter warn-if-wrong-input as="xs:boolean"

Erzeugt eine Fehlermeldung, wenn für den eingegebenen Knoten keine gültige Art ermittelt werden kann. Da die Tests vollständig sind, dürfet dieser Fehler nie auftreten.

xsb:node-kind(1) as="xs:string" (xsl:function)

Shortcut für xsb:node-kind($context, true())

Revision History
Revision 0.612009-11-16Stf

Status: beta

initiale Version

Parameter context as="node()?"

Eingabeknoten (ohne Typ)

xsb:logging-level(2) as="xs:integer" (xsl:function)

Diese Funktion wandelt die verbalen Logging-Level »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« in korrspondierende Integer-Werte von 0 bis 6 um.

Bei einer ungültigen Eingabe wird »4« (entspricht »WARN«) zurückgegeben.

Revision History
Revision 0.1142010-07-16Stf

Status: beta

initiale Version

Parameter verbal-logging-level as="xs:string?"

Eingabeknoten (ohne Typ)

Parameter warn-if-wrong-input as="xs:boolean"

Erzeugt eine Fehlermeldung, wenn der eingegebenen String nicht »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« ist.

xsb:logging-level(1) as="xs:integer" (xsl:function)

Shortcut für xsb:logging-level($verbal-logging-level, true() ).

Revision History
Revision 0.1142010-07-16Stf

Status: beta

initiale Version

Parameter verbal-logging-level as="xs:string?"

Eingabeknoten (ohne Typ)

xsb:vendor-hash(5) as="xs:string" (xsl:function)

Diese Funktion ermittelt aus den übergebenen System-Parameter einen Hashwert, der z.B. für Vergleiche verwendet werden kann

Revision History
Revision 0.1412011-04-25Stf

Status: alpha

initiale Version

Parameter product-name as="xs:string?"

Wert der entsprechenden System-Eigenschaft (String)

Parameter product-version as="xs:string?"

Wert der entsprechenden System-Eigenschaft (String)

Parameter java-available as="xs:boolean"

Wert der entsprechenden System-Eigenschaft (Boolean)

Parameter is-schema-aware as="xs:boolean"

(Boolean)Wert der entsprechenden System-Eigenschaft (muss ggfs. von String umgewandelt werden, etwa mit xsb:parse-string-to-boolean())

Parameter warn-if-wrong-input as="xs:boolean"

Erzeugt eine Fehlermeldung, wenn der eingegebene String nicht in der Liste der gültigen Werte enthalten ist. (Boolean)

xsb:vendor-hash(4) as="xs:string" (xsl:function)

Shortcut für xsb:vendor-hash($product-name, $product-version, $java-available, true()).

Revision History
Revision 0.1412011-04-25Stf

Status: alpha

initiale Version

Parameter product-name as="xs:string?"

Wert der entsprechenden System-Eigenschaft (String)

Parameter product-version as="xs:string?"

Wert der entsprechenden System-Eigenschaft (String)

Parameter java-available as="xs:boolean"

Wert der entsprechenden System-Eigenschaft (Boolean)

Parameter is-schema-aware as="xs:boolean"

(Boolean)Wert der entsprechenden System-Eigenschaft (muss ggfs. von String umgewandelt werden, etwa mit xsb:parse-string-to-boolean())

Parameter warn-if-wrong-input

Erzeugt eine Fehlermeldung, wenn der eingegebene String nicht in der Liste der gültigen Werte enthalten ist. (Boolean)

xsb:java-available(0) use-when="function-available('java-uri:new')" intern:solved="MissingTests" as="xs:boolean" (xsl:function)

Diese Funktion ermittelt – zusammen mit der folgenden – ob Java auf dem ausführenden System zur Verfügung steht.

Revision History
Revision 0.1412011-04-25Stf

Status: alpha

initiale Version

xsb:java-available(0) use-when="not(function-available('java-uri:new') )" intern:solved="MissingTests" as="xs:boolean" (xsl:function)

Diese Funktion ermittelt – zusammen mit der vorhergehenden – ob Java auf dem ausführenden System zur Verfügung steht.

Revision History
Revision 0.1412011-04-25Stf

Status: alpha

initiale Version

xsb:current-vendor-hash(0) as="xs:string" intern:solved="MissingTests" (xsl:function)

Diese Funktion ermittelt den Vendor-Hash für das aktuelle System.

Revision History
Revision 0.1412011-04-25Stf

Status: alpha

initiale Version

xsb:type-annotation(2) as="xs:string" (xsl:function)

ermittelt den Typ eines Atomic Values

Dazu wird das Argument mit einer Reihe von instance of … geprüft. Geprüft werden diejenigen Typen, die ein Basic-XSLT-Prozessor laut XSLT-Standard unterstützen muss (vgl. 3.13 Built-in Types). Das sind xs:double, xs:decimal, xs:integer, xs:float, xs:dateTime, xs:date, xs:time, xs:boolean, xs:yearMonthDuration, xs:dayTimeDuration, xs:duration, xs:string, xs:QName, xs:anyURI, xs:gYearMonth, xs:gMonthDay, xs:gYear, xs:gMonth, xs:gDay, xs:base64Binary, xs:hexBinary, xs:untypedAtomic und xs:anyAtomicType.

Achtung: Die XSLT-Prozessor-Hersteller sind nicht verpflichtet, intern den jeweils »richtigen« Typ zu verwenden, $arg kann auch von einem beliebigen Subtyp sein (vgl. hier).

Revision History
Revision 0.2.252011-05-29Stf

Status: alpha

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabeknoten (ohne Typ)

Parameter warn-if-wrong-input as="xs:boolean"

Erzeugt eine Fehlermeldung, wenn der Typ nicht ermittelt werden kann. Da die Tests vollständig sind und zumindest xs:untypedAtomic immer das Ergebnis sein sollte, dürfet dieser Fehler nie auftreten.

xsb:type-annotation(1) as="xs:string" (xsl:function)

Shortcut für xsb:type-annotation($arg, true() )

Revision History
Revision 0.2.252011-05-29Stf

Status: alpha

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabeknoten (ohne Typ)

xsb:cast(2) intern:solved="MissingTests" as="xs:anyAtomicType" (xsl:function)

wandelt einen Atomic Value beliebigen Types in einen Atomic Value mit Typ entsprechend dem Parameter "as" um

Unterstützt werden diejenigen Typen, die ein Basic-XSLT-Prozessor laut XSLT-Standard unterstützen muss (vgl. 3.13 Built-in Types): xs:double, xs:decimal, xs:integer, xs:float, xs:dateTime, xs:date, xs:time, xs:boolean, xs:yearMonthDuration, xs:dayTimeDuration, xs:duration, xs:string, xs:QName, xs:anyURI, xs:gYearMonth, xs:gMonthDay, xs:gYear, xs:gMonth, xs:gDay, xs:base64Binary, xs:hexBinary, xs:untypedAtomic mit Ausnahme von xs:anyAtomicType (weil ein Cast dahin nicht möglich ist).

Laut Standard kann nicht auf xs:QName gecastet werden, da dieser Cast ein statisches String Literal erfordert und deshalb nicht mit dynamisch zu evaluierenden Variablen bzw. Parametern funktioniert. Details siehe im XPath-Standard, Punkt 4.a., und err:XPTY0004.

Revision History
Revision 0.2.252011-05-29Stf

Status: alpha

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabeknoten (ohne Typ)

Parameter as as="xs:string"

Typ, auf den gecastet werden soll

4. Strings und Texte - strings.xsl

Path: strings.xsl

$Revision: 49 $, $Date: 2012-05-18 01:42:08 +0200 (Fri, 18 May 2012) $

Dieses Stylesheet enthält Funktionen für Strings und Texte.

Da für Testroutinen Funktionen und Templates aus internals.xsl benötigt werden, wird dieses Stylesheet in strings_tests.xsl getestet.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.502012-05-27Stf
neue Funktionen: xsb:fill-left(), xsb:fill-right()
Revision 0.2.492012-05-18Stf
neue Funktionen: xsb:escape-for-replacement(); überarbeitet: xsb:trim-left(), xsb:trim-right(); erweiter: xsb:listed()
Revision 0.2.472012-05-15Stf
neue Funktionen: xsb:sort(), xsb:escape-for-regex(), xsb:count-matches()
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.532009-10-25Stf
Umstellung auf Namespaces xsb: und intern:
Revision 0.362009-08-02Stf
initiale Version

xsb:lax-string-compare(2) as="xs:boolean" (xsl:function)

Verarbeitet Eingabe und Vergleichswert mit normalize-space() und lower-case() und vergleicht dann Eingabe und Vergleichswert. Dadurch werden kleine Differenzen ignoriert.

Revision History
Revision 0.532009-10-25Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

Parameter compare-to as="xs:string?"

Vergleichswert (String)

xsb:return-default-if-empty(2) as="xs:string" (xsl:function)

gibt einen übergebenen Standardwert aus, wenn der übergeben String leer ist oder nur Whitespace enthält, sonst den String selbst

Wenn der übergebene Standardwert eine Leersequenz ist, wird ein Leerstring zurückgegeben.

Revision History
Revision 0.532009-10-25Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

Parameter default as="xs:string?"

Standardwert (String)

xsb:trim-left(1) as="xs:string" (xsl:function)

entfernt führenden Whitespace

Revision History
Revision 0.2.482012-05-18Stf

Status: beta

auf fn:replace() umgeschrieben

Revision 0.532009-10-25Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

xsb:trim-right(1) as="xs:string" (xsl:function)

entfernt Whitespace am Ende eines Strigs

Revision History
Revision 0.2.482012-05-18Stf

Status: beta

auf fn:replace() umgeschrieben

Revision 0.532009-10-25Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

xsb:trim(1) as="xs:string" (xsl:function)

entfernt Whitespace am Anfang und am Ende. Im Unterschied zu normalize-space() wird Whitespace in der Mitte nicht berücksichtigt.

Revision History
Revision 0.532009-10-25Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

xsb:normalize-paragraphs(1) as="xs:string?" intern:solved="EmptySequenceAllowed" (xsl:function)

ersetzt mehrfache Zeilenwechsel durch einen einzelnen Zeilenwechsel. Im Unterschied zu normalize-space() wird ein Zeilenwechsel aber erhalten.

rekursiver Algorithmus: die Funktion ruft sich solange selbst auf, bis keine mehrfachen Zeilenwechsel in der Eingabe vorhanden sind.

Da die Eingabe sinnvoll eine Leersequenz sein kann, ist die Rückgabe einer Leersequenze erlaubt.

Revision History
Revision 0.532009-10-25Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

xsb:listed(2) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob in einer Leerzeichen-getrennten Liste ein bestimmter Eintrag vorhanden ist.

Die Eingabe eines Leerstrings oder einer Leersequenz als Parameter list ergibt false().

Die Eingabe eines Leerstrings oder einer Leersequenz als Parameter item ergibt false().

Revision History
Revision 0.2.482012-05-18Stf

Status: beta

neben Leerzeichen ist jetzt auch anderer Whitespace zum Trennen der String-Token erlaubt

Revision 0.692009-12-05Stf

Status: beta

initiale Version

Parameter list as="xs:string?"

Whitespace-getrennte Liste von String-Token

Parameter item as="xs:string?"

String-Token, auf dessen Existenz getestet werden soll

xsb:return-composed-string-if-not-empty(3) as="xs:string" (xsl:function)

Diese Funktion fügt vor und nach dem zu testenden String die übergebenen Strings ein, wenn der zu testende String nicht leer ist.

Mit dieser Funktion wird die Erzeugung von bedingten Texten vereinfacht, bspw. das Einfügen von Kommata oder Doppelpunkten nach einem Text.

Revision History
Revision 0.962010-06-27Stf

Status: beta

initiale Version

Parameter tested-string as="xs:string?"

getesteter String

Parameter string-before as="xs:string?"

String, der vor dem getesteten String eingefügt werden soll

Parameter string-after as="xs:string?"

String, der nach dem getesteten String eingefügt werden soll

xsb:encode-for-id(1) as="xs:string" (xsl:function)

wandelt einen eingegebenen String in eine xs:ID um, indem verbotene Zeichen ersetzt werden

Revision History
Revision 0.1242010-10-10Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

Eingabe (String)

xsb:sort(1) as="xs:anyAtomicType*" intern:solved="EmptySequenceAllowed" (xsl:function)

Shortcut für xsb:sort($input-sequence, 'ascending')

Revision History
Revision 0.2.472012-05-14Stf

Status: beta

initiale Version

Parameter input-sequence as="xs:anyAtomicType*"

Sequenz von atomic values

xsb:sort(2) as="xs:anyAtomicType*" intern:solved="EmptySequenceAllowed" (xsl:function)

sortiert atomic values

Die Implementierung folgt dem XSLT Beispiel aus dem 2.0-Standard.

Die Werte in der Sequenz müssen mit lt vergleichbar sein. Insbesondere scheitert das Sortieren von gemischten Sequenzen aus Strings und Zahlen.

Revision History
Revision 0.2.472012-05-14Stf

Status: beta

initiale Version

Parameter input-sequence as="xs:anyAtomicType*"

Sequenz von atomic values

Parameter order as="xs:string"

»ascending«/»descending«

xsb:escape-for-regex(1) as="xs:string" (xsl:function)

escapet Steuerzeichen in regulären Ausdrücken mit »\«

Ist input die Leersequenz, wird der Leerstring zurückgegeben.

Beispiele

  • xsb:escape-for-regex('Jan.') ergibt »Jan\.«

  • xsb:escape-for-regex('^1.200$') ergibt »\^1\.200\$«

Revision History
Revision 0.2.472012-05-15Stf

Status: alpha

initiale Version

Parameter input as="xs:string?"

String, der escapet werden soll

xsb:escape-for-replacement(1) as="xs:string" (xsl:function)

escapet Steuerzeichen in Ersetzungstexten für fn:replace()\« und »$«) mit »\«

Ist input die Leersequenz, wird der Leerstring zurückgegeben.

Beispiele

  • xsb:escape-for-replacement('$0') ergibt »\$0«

  • xsb:escape-for-replacement('\1.200$') ergibt »\\1.200\$«

Revision History
Revision 0.2.482012-05-17Stf

Status: alpha

initiale Version

Parameter input as="xs:string?"

String, der escapet werden soll

xsb:count-matches(3) as="xs:integer" (xsl:function)

zählt das Vorkommen eines Suchstrings in einem String

Sind string oder regex Leerstring oder die Leersequenz, wird 0 zurückgegeben.

Beispiele

  • xsb:count-matches('abc def abc', 'def') ergibt »1«

  • xsb:count-matches('abc def abc', 'abc') ergibt »2«

  • xsb:count-matches('abc', '[ab]') ergibt »2«

  • xsb:count-matches('abc', '[ab]+') ergibt »1«

  • xsb:count-matches('Aa', 'a', '') ergibt »1«

  • xsb:count-matches('Aa', 'a', 'i') ergibt »2«

Revision History
Revision 0.2.472012-05-15Stf

Status: beta

initiale Version

Parameter string as="xs:string?"

String, in dem gezählt wird

Parameter regex as="xs:string?"

regulärer Ausdruck, nach dem in string gesucht wird

Parameter flags as="xs:string?"

flags analog zum flags-Parameter von fn:matches() (siehe XQuery 1.0 and XPath 2.0 Functions and Operators (Second Edition), 7.6.6.1 Flags)

xsb:count-matches(2) as="xs:integer" (xsl:function)

Shortcut für xsb:count-matches($string, $regex, '')

Revision History
Revision 0.2.472012-05-16Stf

Status: beta

initiale Version

Parameter string as="xs:string?"

String, in dem gezählt wird

Parameter regex as="xs:string?"

regulärer Ausdruck, nach dem in string gesucht wird

xsb:replace(4) as="xs:string" (xsl:function)

führt wiederholtes paarweises Suchen und Ersetzen über einen String aus

Diese Funktion vereinfachte wiederholtes Suchen und Ersetzen über den selben String. Für jeden Wert aus der pattern-Sequenz wird ein fn:replace() mit dem korrespondierenden Wert (selbe Position) aus der replacement-Sequenz über den Eingabe-String ausgeführt. Sind in der replacement-Sequenz weniger Werte als in der pattern-Sequenz, werden (analog zu fn:translate()) die Fundstellen der »überzähligen« Pattern gelöscht.

Ist input der Leerstring oder die Leersequenz, wird ein Leerstring zurückgegeben.

Ist pattern der Leerstring oder die Leersequenz, wird input unverändert zurückgegeben (Ausnahme: Wenn input die Leersequenz ist, wird ein Leerstring zurückgegeben).

Ist replacement der Leerstring, wird jeder Treffer von pattern in input gelöscht.

Achtung: eine Leersequenz innerhalb der pattern- oder replacement-Sequenz »verschwindet« aus der Sequenz, d.h. die nachfolgenden Werte rücken eine Position nach vorn. Das wird in der Regel nicht der gewünschte Effekt sein!

Beispiele

  • xsb:replace('Affe Bär Elefant', ('Affe', 'Elefant') , ('monkey', 'elephant') ) ergibt »monkey Bär elephant«

  • xsb:replace('Affe Bär Elefant', ('Affe', 'Elefant') , ('monkey', '') ) ergibt »monkey Bär «

  • xsb:replace('Affe Bär Elefant', ('Affe', 'Elefant') , ('monkey') ) ergibt »monkey Bär «

  • xsb:replace('Affe Bär Elefant Löwe', ('Affe', 'Bär', 'Elefant', 'Löwe') , ('monkey', '', 'elephant', 'lion') ) ergibt »monkey elephant lion«

  • xsb:replace('Affe Bär Elefant', ('Affe', '', 'Elefant') , ('monkey', '', 'elephant') ) ergibt »monkey Bär elephant« (Leerstring in der pattern-Sequenz lässt Eingabe unverändert)

  • xsb:replace('Affe Bär Elefant', ('Affe', (), 'Elefant') , ('monkey', '', 'elephant') ) ergibt »monkey Bär « (Leersequenz in der pattern-Sequenz »verschwindet«, dadurch wird Elefant durch den Leerstring ersetzt)

  • xsb:replace('Affe Bär Elefant', ('Affe', 'Bär', 'Elefant') , ('monkey', (), 'elephant') ) ergibt »monkey elephant « (Leersequenz in der replacement-Sequenz »verschwindet«, dadurch wird Bär durch elephant ersetzt, und Elefant wird gelöscht.)

Revision History
Revision 0.2.472012-05-15Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

String, in dem ersetzt wird

Parameter pattern as="xs:string*"

Sequenz von regulären Ausdrücken, nach denen in input gesucht wird

Parameter replacement as="xs:string*"

Sequenz von Ersetzungstexten

Parameter flags as="xs:string?"

flags analog zum flags-Parameter von fn:replace() (siehe XQuery 1.0 and XPath 2.0 Functions and Operators (Second Edition), 7.6.6.1 Flags)

xsb:replace(3) as="xs:string" (xsl:function)

Shortcut für xsb:replace($input, $pattern, $replacement, '')

Revision History
Revision 0.2.472012-05-15Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

String, in dem ersetzt wird

Parameter pattern as="xs:string*"

Sequenz von regulären Ausdrücken, nach denen in input gesucht wird

Parameter replacement as="xs:string*"

Sequenz von Ersetzungstexten

xsb:index-of-first-match(3) as="xs:integer" (xsl:function)

ermittelt die Position des ersten Auftretens von pattern in string

Ist string oder pattern der Leerstring oder die Leersequenz, wird 0 zurückgegeben.

Beispiele

  • xsb:index-of-first-match('ab', 'a') ergibt »1«

  • xsb:index-of-first-match('ab', 'b') ergibt »2«

  • xsb:index-of-first-match('ab', 'c') ergibt »0«

  • xsb:index-of-first-match('ABC', 'b', '') ergibt »0«

  • xsb:index-of-first-match('ABC', 'b', 'i') ergibt »2«

Revision History
Revision 0.2.472012-05-16Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

String, in dem gesucht wird

Parameter pattern as="xs:string?"

regulärer Ausdruck, nach dem in input gesucht wird

Parameter flags as="xs:string?"

flags analog zum flags-Parameter von fn:tokenize() (siehe XQuery 1.0 and XPath 2.0 Functions and Operators (Second Edition), 7.6.6.1 Flags)

xsb:index-of-first-match(2) as="xs:integer" (xsl:function)

Shortcut für xsb:index-of-first-match($input, $pattern, '')

Revision History
Revision 0.2.472012-05-16Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

String, in dem gesucht wird

Parameter pattern as="xs:string?"

regulärer Ausdruck, nach dem in input gesucht wird

xsb:fill-left(3) as="xs:string" (xsl:function)

füllt $input links bis zur Länge $length mit dem Zeichen $fill-with auf

Bei einem Leerstring oder einer Leersequenz als $input wird vollständig mit $fill-with aufgefüllt.

Bei einem Leerstring oder einer Leersequenz als $fill-with wird $input unverändert zurückgegeben.

Ist $input länger als $fill-with, wird $input unverändert zurückgegeben.

Beispiele

  • xsb:fill-left('X', '-', 4) ergibt »---X«

  • xsb:fill-left('', '-', 4) ergibt »----«

  • xsb:fill-left('X', '', 4) ergibt »X«

  • xsb:fill-left('sieben', '-', 4) ergibt »sieben«

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

String, der aufgefüllt werden soll

Parameter fill-with as="xs:string?"

Zeichen, mit dem aufgefüllt werden soll

Parameter length as="xs:integer"

Anzahl Zeichen, auf die aufgefüllt werden soll

xsb:fill-right(3) as="xs:string" (xsl:function)

füllt $input rechts bis zur Länge $length mit dem Zeichen $fill-with auf

Bei einem Leerstring oder einer Leersequenz als $input wird vollständig mit $fill-with aufgefüllt.

Bei einem Leerstring oder einer Leersequenz als $fill-with wird $input unverändert zurückgegeben.

Ist $input länger als $fill-with, wird $input unverändert zurückgegeben.

Beispiele

  • xsb:fill-right('X', '-', 4) ergibt »X---«

  • xsb:fill-right('', '-', 4) ergibt »----«

  • xsb:fill-right('X', '', 4) ergibt »X«

  • xsb:fill-right('sieben', '-', 4) ergibt »sieben«

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

initiale Version

Parameter input as="xs:string?"

String, der aufgefüllt werden soll

Parameter fill-with as="xs:string?"

Zeichen, mit dem aufgefüllt werden soll

Parameter length as="xs:integer"

Anzahl Zeichen, auf die aufgefüllt werden soll

5. Logging-System - internals.logging.xsl

Path: internals.logging.xsl

$Revision: 37 $, $Date: 2011-06-26 22:53:01 +0200 (Sun, 26 Jun 2011) $

Dieses Stylesheet stellt ein API für das Logging zur Verfügung. Die Templates sind nicht zur direkten Benutzung gedacht; vielmehr sollen externe Wrapper dieses API nutzen. Dadurch kann der Logging-Unterbau ggfs. ausgetauscht werden.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.532009-10-25Stf
Umstellung auf Namespaces xsb: und intern:
Revision 0.472009-10-11Stf
Ausgliederung von Logging aus internals.xsl
Revision 0.362009-08-02Stf
initiale Version

intern:internals.logging.Output (xsl:template)

Dieses Template ist der zentrale Einstieg zur Realisierung des Logging. Es nimmt die Logging-Parameter entgegen, wandelt sie in Tunnel-Parameter um und ruft den Dispatcher intern:internals.logging.Dispatcher auf. Es ist recht abstrakt und sollte zur Benutzung von Wrappern (wie z.B. xsb:internals.Logging) umgeben werden.

Diese Template ist auch für die Umwandlung der übergebenen Parameter in getunnelte Parameter zuständig.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.preText as="xs:string?" required="no"

Text, der ganz am Anfang der Ausgabe geschrieben wird. Bei Ausgabe als Text oder auf die Konsole kann darüber bspw. eine Einrückung realisiert werden. Bei Ausgabe als XML wird dieser Text der Nachricht hinzugefügt, bei Ausgabe als HTML wird eine zusätzliche Tabellenspalte erzeugt.

Parameter log-entry.ID as="xs:string?" required="no"

Message-ID

Parameter log-entry.timeStamp as="xs:dateTime?" required="no"

Zeitstempel der Nachricht.

Parameter log-entry.processedFile as="xs:string?" required="no"

Name der Datei, die bei Erzeugung der Nachricht transformiert wurde.

Parameter log-entry.level as="xs:string?" required="no"

Level der Nachricht. In Anlehnung an Log4j werden per Vorgabe die Stufen »ALL« > »TRACE« > »DEBUG« > »INFO« > »WARN« > »ERROR« > »FATAL« (in aufsteigender Reihenfolge der Wichtigkeit) verwendet.

Parameter log-entry.text as="xs:string?" required="no"

Nachrichtentext

Parameter log-entry.category as="xs:string?" required="no"

Kategorie der Nachricht, dient als zusätzliches Unterscheidungsmerkmal bei der externen Auswertung, z.B. "Fehler", "Abrechnung" oder "Hauptroutine"

Parameter log-entry.postText as="xs:string?" required="no"

Text, der ganz am Ende der Ausgabe geschrieben wird. Die konkrete Ausgabe wird in den entsprechenden intern:internals.logging.Render-to-xxx-Templates erzeugt; beispielsweise wird bei Ausgabe als XML dieser Text von intern:internals.logging.Render-to-xml hinter $log-entry.text eingefügt.

Parameter log-entry.linebreak-string as="xs:string?" required="no"

String, der bei einem Zeilenumbruch ausgegeben wird, im Normalfall 
.

Parameter log-entry.write-to-console as="xs:boolean" required="yes"

Wenn true(), wird die Nachricht auf die Konsole ausgegeben

Parameter log-entry.write-to-file as="xs:boolean" required="yes"

Wenn true(), wird die Nachricht in die Ausgabedatei geschrieben

Parameter log-entry.write-to-file-as-comment as="xs:boolean" required="yes"

Wenn true(), wird die Nachricht als Kommentar in die Ausgabedatei geschrieben

Parameter log-entry.write-to-file-as-element as="xs:boolean" required="yes"

Wenn true(), wird die Nachricht als XML-Element in die Ausgabedatei geschrieben

Parameter log-entry.write-to-file-as-html as="xs:boolean" required="yes"

Wenn true(), wird die Nachricht als HTML in die Ausgabedatei geschrieben

Parameter log-entry.write-to-file-as-text as="xs:boolean" required="yes"

Wenn true(), wird die Nachricht als Text in die Ausgabedatei geschrieben

Parameter log-entry.write-preText as="xs:boolean" required="yes"

Wenn true(), wird der Pre-Text mit der Nachricht ausgegeben

Parameter log-entry.write-ID as="xs:boolean" required="yes"

Wenn true(), wird die ID der Nachricht ausgegeben

Parameter log-entry.write-timeStamp as="xs:boolean" required="yes"

Wenn true(), wird der Zeitstempel der Nachricht ausgegeben

Parameter log-entry.write-processedFile as="xs:boolean" required="yes"

Wenn true(), wird der Name der transformierten Datei mit der Nachricht ausgegeben

Parameter log-entry.write-level as="xs:boolean" required="yes"

Wenn true(), wird der Level der Nachricht ausgegeben

Parameter log-entry.write-text as="xs:boolean" required="yes"

Wenn true(), wird der Text der Nachricht ausgegeben

Parameter log-entry.write-category as="xs:boolean" required="yes"

Wenn true(), wird die Kategorie der Nachricht ausgegeben

Parameter log-entry.write-postText as="xs:boolean" required="yes"

Wenn true(), wird der Post-Text mit der Nachricht ausgegeben

intern:internals.logging.Dispatcher (xsl:template)

Dieses Template verteilt die Nachrichten an die passenden Ausgabe-Templates. Parameter werden über tunnel="yes" durchgereicht (getunnelt).

Dieses zwischengeschaltete Template vermeidet außerdem, dass die Umwandlung in Tunnel-Parameter innerhalb von internal:internals.logging.Output mehrfach vorgenommen werden muss.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.write-to-console.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-to-file.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-to-file-as-comment.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-to-file-as-element.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-to-file-as-html.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-to-file-as-text.tunneld as="xs:boolean" tunnel="yes" required="yes"

intern:internals.logging.Write-to-console (xsl:template)

Dieses Template gibt die Nachricht auf der Konsole aus. Parameter werden über tunnel="yes" an das Template intern:internals.logging.Render-to-string durchgereicht (getunnelt).

Das Template wird normalerweise von intern:internals.logging.Output aufgerufen.

Hook: kann zum Umleiten oder Umformatieren überschrieben werden.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

intern:internals.logging.Write-to-file-as-comment as="comment()" (xsl:template)

Dieses Template gibt die Nachricht als Kommentar in den Output-Stream (in der Regel: die Ergebnis-Datei) aus. Parameter werden über tunnel="yes" an das Template intern:internals.logging.Render-to-string durchgereicht (getunnelt).

Das Template wird normalerweise von intern:internals.logging.Output aufgerufen.

Hook: kann zum Umleiten oder Umformatieren überschrieben werden.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

intern:internals.logging.Write-to-file-as-element as="node()*" intern:solved="EmptySequenceAllowed" (xsl:template)

Dieses Template gibt die Nachricht als XML-Element in den Output-Stream (in der Regel: die Ergebnis-Datei) aus. Parameter werden über tunnel="yes" an das Template intern:internals.logging.Render-to-xml durchgereicht (getunnelt).

Das Template wird normalerweise von intern:internals.logging.Output aufgerufen.

Hook: kann zum Umleiten oder Umformatieren überschrieben werden.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.linebreak-string.tunneld as="xs:string?" tunnel="yes" required="no"

intern:internals.logging.Write-to-file-as-html as="node()+" (xsl:template)

Dieses Template gibt die Nachricht als HTML-Elemente in den Output-Stream (in der Regel: die Ergebnis-Datei) aus. Parameter werden über tunnel="yes" an das Template intern:internals.logging.Render-to-html durchgereicht (getunnelt).

Das Template wird normalerweise von intern:internals.logging.Output aufgerufen.

Hook: kann zum Umleiten oder Umformatieren überschrieben werden.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

intern:internals.logging.Write-to-file-as-text as="xs:string*" intern:solved="EmptySequenceAllowed" (xsl:template)

Dieses Template gibt die Nachricht als Text in den Output-Stream (in der Regel: die Ergebnis-Datei) aus. Parameter werden über tunnel="yes" an das Template intern:internals.logging.Render-to-string durchgereicht (getunnelt).

Das Template wird normalerweise von intern:internals.logging.Output aufgerufen.

Hook: kann zum Umleiten oder Umformatieren überschrieben werden.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.linebreak-string.tunneld as="xs:string?" tunnel="yes" required="no"

intern:internals.logging.Render-to-string as="xs:string?" intern:solved="EmptySequenceAllowed" (xsl:template)

Dieses Template rendert die Message-Parameter als Text. Parameter werden über tunnel="yes" empfangen (getunnelt).

Werden keine Parameter übergeben, wird eine empty sequence zurückgegeben.

Hook: kann zum Umformatieren überschrieben werden.

Revision History
Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.preText.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.ID.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.timeStamp.tunneld as="xs:dateTime?" tunnel="yes" required="no"

Parameter log-entry.processedFile.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.level.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.text.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.category.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.postText.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.write-preText.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-ID.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-timeStamp.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-processedFile.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-level.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-text.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-category.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-postText.tunneld as="xs:boolean" tunnel="yes" required="yes"

intern:internals.logging.Render-to-xml as="node()" (xsl:template)

Dieses Template rendert die Message-Parameter als XML-Elemente. Parameter werden über tunnel="yes" empfangen (getunnelt).

Die Nachricht wird in ein message-Element mit Kindelementen umgewandelt.

Hook: kann zum Umformatieren überschrieben werden.

Revision History
Revision 0.1392011-04-24Stf

Status: beta

Trennung von preText, Text und postText

Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.preText.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.ID.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.timeStamp.tunneld as="xs:dateTime?" tunnel="yes" required="no"

Parameter log-entry.processedFile.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.level.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.text.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.category.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.postText.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.write-preText.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-ID.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-timeStamp.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-processedFile.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-level.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-text.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-category.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-postText.tunneld as="xs:boolean" tunnel="yes" required="yes"

intern:internals.logging.Render-to-html as="node()+" (xsl:template)

Dieses Template rendert die Message-Parameter als HTML-Elemente. Parameter werden über tunnel="yes" empfangen (getunnelt).

Hook: kann zum Umformatieren überschrieben werden.

Revision History
Revision 0.1412011-04-25Stf

Status: beta

log-entry.command entfernt

Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.preText.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.ID.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.timeStamp.tunneld as="xs:dateTime?" tunnel="yes" required="no"

Parameter log-entry.processedFile.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.level.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.text.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.category.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.postText.tunneld as="xs:string?" tunnel="yes" required="no"

Parameter log-entry.write-preText.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-ID.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-timeStamp.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-processedFile.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-level.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-text.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-category.tunneld as="xs:boolean" tunnel="yes" required="yes"

Parameter log-entry.write-postText.tunneld as="xs:boolean" tunnel="yes" required="yes"

intern:internals.logging.MakeHeader.element (xsl:template)

Dieses Template erzeugt bei der Ausgabe als xml den Kopf, speziell das öffnende Element

Revision History
Revision 0.1392011-04-24Stf

Status: alpha

initiale Version

intern:internals.logging.MakeHeader.html exclude-result-prefixes="#all" (xsl:template)

Dieses Template erzeugt bei der Ausgabe als xml den Kopf, speziell das öffnende Element

Revision History
Revision 0.1392011-04-24Stf

Status: alpha

initiale Version

Parameter titel as="xs:string?" required="no"

optionaler Seitentitel

intern:internals.logging.MakeFooter.element (xsl:template)

Dieses Template erzeugt bei der Ausgabe als XML den Fuß, speziell das schließende Element

Revision History
Revision 0.1392011-04-24Stf

Status: alpha

initiale Version

intern:internals.logging.MakeFooter.html exclude-result-prefixes="#all" (xsl:template)

Dieses Template erzeugt bei der Ausgabe als HTML den Fuß, speziell die schließenden Tags

Revision History
Revision 0.1392011-04-24Stf

Status: alpha

initiale Version

intern:internals.logging.MakeThead.HTML as="node()" (xsl:template)

Dieses Template erzeugt eine Zeile mit dem Tabellenkopf für die Ausgabe als HTML. Die Signatur des Templates entspricht einem normalen Logging-Eintrag (mit Ausnahme von log-entry.timeStamp, das hier xs:string ist), die übergebenen Werte werden in die Spaltenüberschriften geschrieben. Werden keine Werte übergeben, werden Standardwerte verwendet.

Hook: kann zum Umformatieren überschrieben werden.

Revision History
Revision 0.1412011-04-25Stf

Status: beta

als selbständiges Template neben der Logging-Infrastruktur umgeschrieben

Revision 0.532009-10-25Stf

Status: beta

Umstellung auf Namespaces xsb: und intern:

Revision 0.362009-08-02Stf

Status: beta

initiale Version

Parameter log-entry.preText as="xs:string?" required="no"

Parameter log-entry.ID as="xs:string?" required="no"

Parameter log-entry.timeStamp as="xs:string?" required="no"

Parameter log-entry.processedFile as="xs:string?" required="no"

Parameter log-entry.level as="xs:string?" required="no"

Parameter log-entry.text as="xs:string?" required="no"

Parameter log-entry.category as="xs:string?" required="no"

Parameter log-entry.postText as="xs:string?" required="no"

Parameter log-entry.write-preText as="xs:boolean" required="no"

Parameter log-entry.write-ID as="xs:boolean" required="no"

Parameter log-entry.write-timeStamp as="xs:boolean" required="no"

Parameter log-entry.write-processedFile as="xs:boolean" required="no"

Parameter log-entry.write-level as="xs:boolean" required="no"

Parameter log-entry.write-text as="xs:boolean" required="no"

Parameter log-entry.write-category as="xs:boolean" required="no"

Parameter log-entry.write-postText as="xs:boolean" required="no"

6. Mathematische Funktionen - math.xsl

Path: math.xsl

Import statements:

$Revision: 46 $, $Date: 2012-03-25 18:47:58 +0200 (So, 25 Mrz 2012) $

Dieses Stylesheet liefert mathematische Konstanten und berechnet mathematische Funktionen.

Die trigonometrischen und Exponential-Funktionen von XPath 3.0 sind vollständig implementiert. Daneben gibt es weitere »praktische« Funktionen wie xsb:fact (Fakultät).

Autoren: Dr. Thomas Meinike (http://datenverdrahten.de/) und Stefan Krause

Die Benennung der Funktionen folgt den Vorgaben von XPath 3.0 (vgl. http://www.w3.org/TR/xpath-functions-30/).

Viele Funktionen gibt es in zwei Varianten: eine im Namensraum xsb: und eine im Namensraum intern:. Die Funktionen im Namensraum xsb: prüfen die Funktionsargumente auf Gültigkeit und liefern gerundete Ergebnisse (siehe intern:round). Die Funktionen im Namensraum intern: verzichten auf Tests der Argumente (soweit sich das sauber trennen lässt, was bei -0.0e0 und -INF/INF nicht immer sauber möglich ist) und liefern mit intern:iround gerundete oder auch ungerundete Ergebnisse der jeweiligen Algorithmen, damit intern mit höherer Geschwindigkeit und genaueren Werten gerechnet werden kann.

Die Funktionen liefern i.d.R. ihre Ergebnisse mit dem Typ der (ersten) Arguments (dynamische Typung). Bei Funktionen, die -INF, INF oder NaN als Ergebnis liefern, schlägt ggfs. der Cast des Ergebnisses auf ungeeignete Typen wie xs:decimal oder xs:integer fehl. In diesen Fällen kann das Argument bspw. explizit als xs:double übergeben werden.

Die Parameter der Funktionen im Namensraum xsb: sind – soweit nicht anders erforderlich – ungetypt, um keine Casts bei der Parameterübergabe zu erzwingen.

Hinweise:

Bezüglich Typung, Verhalten bei Leersequenzen, +/-INF, NaN usw. kann es Abweichungen gegenüber dem XPath-3.0-Standard geben, wobei in Zukunft Anpassungen an den Standard möglich sind (inklusive eigentlich verbotener Änderungen der Tests).

Die Berechnung mancher Funktionen (wie xsb:nroot oder xsb:log) erfolgt über Näherungen und Reihenentwicklungen. Die Algorithmen sind nicht in Bezug auf Geschwindigkeit und Genauigkeit optimiert, d.h. es kann zu unerwartet langen Ausführungszeiten und falschen Ergebnissen kommen. Vor dem Einsatz dieser Funktionen in kritischen Anwendungen sind unbedingt umfangreiche Tests erforderlich.

Bei der Berechnung der Funktionen können zwei Fehlertypen auftreten:

  • mathematische Fehler: das Ergebnis einer Funktion ist für den eingegebenen Wert nicht definiert (bspw. log(-2) oder sqrt(-2)). In diesem Fall wird NaN ausgegeben.

  • technischer Fehler: die Software bzw. der Algorithmus ist nicht für die Verarbeitung einer bestimmten Eingabe geeignet (bspw. benötigt intern:power als Exponenten eine nichtnegative Ganzzahl). In diesem Fall bricht das Stylesheet die Verarbeitung ab.

    (Dieses Problem hätte zwar mit einer genaueren Typung umgangen werden können, aber Basic XSLT-Prozessoren unterstützen nicht alle Datentypen (wie xs:nonNegativeInteger).)

Die intern:*-Funktionen werden i.d.R. nicht getestet, weil die Tests über die xsb:*-Pendants erfolgen.

Die Konstanten und die Vergleichwerte für Tests wurden mit Hilfe von WolframAlpha ermittelt. Für diese Unterstützung möchte ich mich sehr herzlich bedanken, diese Website hat die Entwicklung dieses Stylesheets sehr beschleunigt.

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

neue Funktionen: xsb:integer-to-hex(), xsb:twos-complement(), xsb:reverse-twos-complement() und xsb:hex-to-integer($input, $n)

Revision 0.2.372011-06-26Stf

Status: beta

Ergänzung der Arkus-Funktionen, Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: alpha

Umstellung von xs:double auf xs:decimal, Optimierungen, Anpassungen

Revision 0.2.122011-05-21Stf

Status: draft

initiale Version auf der Grundlage der Bibliothek von Thomas Meinike (Original-URL http://datenverdrahten.de/xslt2/tm_mathlib.xsl)

intern:max as="xs:integer" select="80" (xsl:variable)

Anzahl der Glieder für Reihenentwicklungen

Die maximale Zahl von Iterationen und damit die Genauigkeit der Reihenentwicklungen lässt sich über den Wert der Variable $intern:max steuern.

In der Regel konvergieren die Reihenglieder gegen 0, und die Reihenbildung wird abgebrochen, wenn das Reihenglied, gerundet mit intern:iround, zu Null wird.

$intern:max kann herabgesetzt werden, um zu Lasten der Genauigkeit eine schnellere Berechnung zu erzielen (ggfs. in Verbindung mit einer Herabsetzung von $intern:round bzw. $intern:iround).

Außerdem sorgt diese Variable für einen Abbruch der Reihenbildung, falls aus irgendeinem Grund (etwa Rundungsungenauigkeiten) der Algorithmus nicht konvergiert.

intern:round as="xs:integer" select="16" (xsl:variable)

Stellen für Ergebnis-Rundung

Am Ende der Berechnung werden die Ergebnisse auf diese Anzahl der Stellen gerundet. Default: 16

Der Defaultwert ergibt sich aus der Anforderung, dass jeder standardkonforme XSLT-Prozessor mindestens 18 Digits unterstützen muss, vgl. XML Schema Part 2: Datatypes Second Edition. Da es bei mehrstufigen Berechnungen zu Rundungsfehlern kommen kann, ist die Anzahl der signifikanten Stellen ein Kompromiss. Ich habe mich für 16 Stellen entschieden, weil damit die meisten Tests erfolgreich verlaufen (Details siehe Testergebnisse).

intern:iround as="xs:integer" select="32" (xsl:variable)

Stellen für interne Ergebnis-Rundung

Am Ende der Berechnung werden die Ergebnisse auf diese Anzahl der Stellen gerundet. Default: 32 (das Doppelte von intern:round)

Hinweis: Intern müssen XSLT-Prozessoren nicht mit dieser Auflösung rechnen, und diese 32 Stellen müssen nicht signifikant oder richtig sein.

xsb:pi(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Konstante Pi mit 3,14159265358979323846264338327950288419716939937511…

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

xsb:tau(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Konstante Tau mit 2 * Pi = 6,28318530717958647692528676655900576839433879875021…

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

xsb:e(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Konstante e (Eulersche Zahl) mit 2,718281828459045235360287471353…

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

intern:ln2(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

natürlicher Logarithmus von 2 mit 0,69314718055994530941723212145818 (Konstante)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

intern:ln10(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

natürlicher Logarithmus von 10 mit 2,3025850929940456840179914546844… (Konstante)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

intern:sqrt2(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Wurzel aus 2 mit 1,4142135623730950488… (Konstante)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

intern:half-pi(0) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Pi/2 (Konstante)

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

initiale Version

xsb:fact(1) as="xs:anyAtomicType" (xsl:function)

berechnet die Fakultät einer natürlichen Zahl

Die Eingabe einer ungültigen Zahl (kleiner 0) führt zum Abbruch (mit Fehlermeldung)

Revision History
Revision 0.2.342011-06-19Stf

Status: beta

Umstellung auf intern:fact() und dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter n as="xs:anyAtomicType"

natürliche Zahl (einschließlich 0)

intern:fact(1) as="xs:integer" intern:solved="MissingTests" (xsl:function)

berechnet die Fakultät einer natürlichen Zahl

Es findet hier keine Typprüfung und keine Gültigkeitsprüfung des Argumentes statt.

Revision History
Revision 0.2.342011-06-19Stf

Status: beta

initiale Version

Parameter n as="xs:integer"

natürliche Zahl (einschließlich 0)

xsb:pow(2) as="xs:anyAtomicType" (xsl:function)

berechnet die Potenz basis^exponent

Bei ganzzahligen Exponenten wird die multiplikative Variante mit intern:power() ausgeführt, bei gebrochenen Exponenten wird eine Näherung berechnet.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

Aufteilung in xsb:pow und intern:pow, Lösung für negative Exponenten

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter basis as="xs:anyAtomicType"

Basis

Parameter exponent as="xs:anyAtomicType"

Exponent

intern:pow(2) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet die Potenz basis^exponent

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter basis as="xs:anyAtomicType"

Basis

Parameter exponent as="xs:anyAtomicType"

Exponent

intern:power(2) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet die Potenz basis^exponent für ganzzahlige Exponenten (multiplikative Methode)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

Berücksichtigung negativer Exponenten

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter basis as="xs:anyAtomicType"

Basis

Parameter exponent as="xs:integer"

Exponent, Ganzzahl

xsb:exp(1) as="xs:anyAtomicType" (xsl:function)

Exponential-Funktion e^exponent

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter exponent as="xs:anyAtomicType"

Exponent der e-Funktion

intern:exp(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Exponential-Funktion e^exponent

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter exponent as="xs:anyAtomicType"

Exponent der e-Funktion

intern:exp-iterator(5) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Iterator zur Berechnung der e-Funktion (Reihenbildung)

Die Anzahl der Iterationen resp. Genauigkeit wird von $intern:max und $intern:iround beeinflusst.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter exponent as="xs:anyAtomicType"

Exponent der e-Funktion

Parameter vortrag as="xs:anyAtomicType"

Vortrag der Reihenbildung, wird mit 1 initialisiert

Parameter iteration as="xs:integer"

Zähler für Anzahl der Iterationen; wird mit 1 initialisiert

Parameter pow-vortrag as="xs:anyAtomicType"

Vortrag der Potenz, wird mit 1 initialisiert

Parameter fact-vortrag as="xs:integer"

Vortrag der Fakultät, wird mit 1 initialisiert

xsb:exp10(1) as="xs:anyAtomicType" (xsl:function)

Exponential-Funktion 10^exponent (Zehnerpotenzen)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter exponent as="xs:anyAtomicType"

Exponent

intern:exp10(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet die Potenz zur Basis 10

Bei ganzzahligen Exponenten wird die multiplikative Variante mit intern:power() ausgeführt, bei gebrochenen Exponenten wird eine Näherung berechnet.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter exponent as="xs:anyAtomicType"

Exponent

xsb:sin(1) as="xs:anyAtomicType" (xsl:function)

Sinus-Funktion (Reihenentwicklung)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

umgeschrieben auf intern:sinus-iterator()

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

intern:sin(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet den Sinus

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

intern:sinus-iterator(3) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Iterator zur Berechnung des Sinus

Die Anzahl der Iterationen resp. Genauigkeit wird von $intern:max und $intern:iround beeinflusst.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter NormalisiertesArgument as="xs:anyAtomicType"

Winkel im Bogenmaß, normalisiert auf den Bereich zwischen - 2 * Pi und 2 * Pi

Parameter vortrag as="xs:anyAtomicType"

Vortrag

Parameter iteration as="xs:integer"

Zähler für Anzahl der Iterationen; wird mit 0 initialisiert

xsb:cos(1) as="xs:anyAtomicType" (xsl:function)

berechnet den Cosinus

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

umgeschrieben auf intern:cosinus-iterator()

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

intern:cos(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet den Cosinus

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

intern:cosinus-iterator(3) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Iterator zur Berechnung des Kosinus

Die Anzahl der Iterationen resp. Genauigkeit wird von $intern:max und $intern:iround beeinflusst.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter NormalisiertesArgument as="xs:anyAtomicType"

Winkel im Bogenmaß, normalisiert auf den Bereich zwischen - 2 * Pi und 2 * Pi

Parameter vortrag as="xs:anyAtomicType"

Vortrag

Parameter iteration as="xs:integer"

Zähler für Anzahl der Iterationen; wird mit 0 initialisiert

intern:normalize-rad(1) as="xs:anyAtomicType" (xsl:function)

rechnet Winkel auf den Bereich von - 2 * Pi bis 2 * Pi um

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter rad as="xs:anyAtomicType"

Winkel im Bogenmaß

xsb:tan(1) as="xs:anyAtomicType" (xsl:function)

berchnet den Tangens

Da als Ergebnis -/+INF ausgegeben werden kann, schlägt in diesen Fällen ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: alpha

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

intern:tan(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berchnet den Tangens

Da als Ergebnis -/+INF ausgegeben werden kann, schlägt in diesen Fällen ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

xsb:cot(1) as="xs:anyAtomicType" (xsl:function)

berechnet den Cotangens

Da als Ergebnis -/+INF ausgegeben werden kann, schlägt in diesen Fällen ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

intern:cot(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet den Cotangens

Da als Ergebnis -/+INF ausgegeben werden kann, schlägt in diesen Fällen ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert, als Bogenmaß

xsb:deg-to-rad(1) as="xs:anyAtomicType" (xsl:function)

wandelt Gradmaß in Bogenmaß um

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter deg as="xs:anyAtomicType"

Eingabe im Gradmaß

intern:deg-to-rad(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

wandelt Gradmaß in Bogenmaß um

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter deg as="xs:anyAtomicType"

Eingabe im Gradmaß

xsb:rad-to-deg(1) as="xs:anyAtomicType" (xsl:function)

rechnet Bogenmaß in Gradmaß um

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter rad as="xs:anyAtomicType"

Eingabe im Bogenmaß

intern:rad-to-deg(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

rechnet Bogenmaß in Gradmaß um

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter rad as="xs:anyAtomicType"

Eingabe im Bogenmaß

xsb:sqrt(1) as="xs:anyAtomicType" (xsl:function)

berechnet die Quadratwurzel

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert

intern:sqrt(1) as="xs:anyAtomicType" (xsl:function)

berechnet die Quadratwurzel, Shortcut für intern:nroot($arg, 2)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Eingabewert

xsb:nroot(2) as="xs:anyAtomicType" (xsl:function)

berechnet die n-te Wurzel (n = Wurzelexponent)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter wurzelbasis as="xs:anyAtomicType"

Wurzelbasis (Radikand)

Parameter wurzelexponent as="xs:integer"

Wurzelexponent; muss eine natürliche Zahl sein

intern:nroot(2) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet die n-te Wurzel (n = Wurzelexponent)

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter wurzelbasis as="xs:anyAtomicType"

Wurzelbasis (Radikand)

Parameter wurzelexponent as="xs:integer"

Wurzelexponent; muss eine natürliche Zahl sein

intern:root-iterator(5) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

iterative Wurzelberechnung nach dem Heron-Verfahren

Die Anzahl der Iterationen resp. Genauigkeit wird von $intern:max und $intern:iround beeinflusst.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter n as="xs:integer"

Wurzelexponent

Parameter x as="xs:anyAtomicType"

Wurzelbasis (Radikand)

Parameter y as="xs:anyAtomicType"

Vortrag; wird mit 0 initialisiert

Parameter yn as="xs:anyAtomicType"

Vortrag; wird mit Wurzelbasis initialisiert

Parameter iteration as="xs:integer"

Zähler für Anzahl der Iterationen; wird mit 0 initialisiert

xsb:log(1) as="xs:anyAtomicType" (xsl:function)

berechnet den natürlichen Logarithmus

Da als Ergebnis -INF/INF/NaN ausgegeben werden kann, schlägt in diesen Fällen ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument

intern:log(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet den natürlichen Logarithmus (Logarithmus zur Basis e)

Da der Algorithmus von intern:log-iterator besonders gut für Argumente zwischen 1/sqrt(2) und sqrt(2) konvergiert, werden die Argumente in diesen Bereich transformiert. Zuerst wird mit intern:log-m-iterator ein passender Faktor m ermittelt. Das gesuchte Ergebnis ergibt sich über die Beziehung log(x) = 2 * m * log(sqrt(2)) + log((2^ -m) * x).

Da als Ergebnis -INF ausgegeben werden kann (für $arg = 0), schlägt in diesem Fall ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument

intern:log-m-iterator(2) as="xs:integer" (xsl:function)

ermittelt einen Faktor, um intern:log-iterator in einem Bereich mit günstiger Konvergenz ausführen zu können.

Details siehe intern:log()

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter x as="xs:anyAtomicType"

Argument der log()-Funktion

Parameter m as="xs:integer"

Vortrag; wird mit 0 initialisiert

intern:log-iterator(5) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Iteration zur Ermittlung des natürlichen Logarithmus

Die Anzahl der Iterationen resp. Genauigkeit wird von $intern:max und $intern:iround beeinflusst.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter argm as="xs:anyAtomicType"

ursprüngliches Argument + 1

Parameter argp as="xs:anyAtomicType"

ursprüngliches Argument - 1

Parameter vortrag as="xs:anyAtomicType"

zur Übergabe des Ergebnisses aus den vorherigen Iterationen; wird mit 0 initialisiert

Parameter iteration as="xs:integer"

Zähler für Anzahl der Iterationen; wird mit 0 initialisiert

Parameter n-iteration as="xs:integer"

weiterer Zähler; wird mit 1 initialisiert

xsb:log10(1) as="xs:anyAtomicType" (xsl:function)

berechnet den Logarithmus zur Basis 10 (dekadischer Logarithmus) und rundet das Ergebnis

Da als Ergebnis -INF/INF/NaN ausgegeben werden kann, schlägt in diesen Fällen ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument

intern:log10(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet den Logarithmus zur Basis 10 (dekadischer Logarithmus)

Da als Ergebnis -INF ausgegeben werden kann (für $arg = 0), schlägt in diesem Fall ein Cast auf ungeeignete Typen (wie xs:decimal) fehl.

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument

xsb:fibonacci(1) as="xs:integer" (xsl:function)

berechnet Fibonacci-Zahlen

Revision History
Revision 0.2.252011-05-29Stf

Status: beta

Neue Implementierung auf der Grundlage von xsb:fibonacci-sequence

Revision 0.2.122011-05-21TM

Status: beta

initiale Version

Parameter n as="xs:integer"

Argument (positive natürliche Zahl)

xsb:fibonacci-sequence(1) as="xs:integer+" (xsl:function)

berechnet Fibonacci-Reihen

Revision History
Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter n as="xs:integer"

Argument (positive natürliche Zahl)

intern:fibonacci-sequence(2) as="xs:integer+" intern:solved="MissingTests" (xsl:function)

berechnet rekursiv Fibonacci-Reihen, in dem an eine vorhandene Reihe die Summe aus vorletztem und letztem Item angefügt wird.

Die Initalisierung erfolgt in der Regel über xsb:fibonacci-sequence($n as xs:integer), so das hier auf Typechecks verzichtet werden kann (was einer höheren Ausführungsgeschwindigkeit zu gute kommt).

Revision History
Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter n as="xs:integer"

Argument (positive natürliche Zahl), Anzahl der anzuhängenden Fibonacci-Zahlen (- 1, weil die Startsequenz in der Regel (0, 1) ist)

Parameter vortrag as="xs:integer*"

Sequenz von Fibonacci-Zahlen

intern:round(1) as="xs:anyAtomicType" (xsl:function)

rundet Zahlen einheitlich für die Ausgabe der mathematischen Funktionen der XSLT-SB

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

zu rundende Zahl

intern:iround(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

rundet Zahlen für interne Zwecke

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

Umstellung auf dynamische Typung

Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

zu rundende Zahl

intern:format-INF-caller(2) as="xs:string" intern:solved="MissingTests" (xsl:function)

formatiert einen String für die Fehlerausgabe

Revision History
Revision 0.2.252011-05-29Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der aufrufenden Funktion

Parameter caller as="xs:string"

Name der aufrufenden Funktion

xsb:asin(1) as="xs:anyAtomicType" (xsl:function)

ermittelt den Arkussinus (im Bogenmaß)

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der xsb:asin()-Funktion

intern:asin(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

ermittelt den Arkussinus (im Bogenmaß)

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der intern:asin()-Funktion

xsb:acos(1) as="xs:anyAtomicType" (xsl:function)

ermittelt den Arkuskosinus (im Bogenmaß)

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der xsb:acos()-Funktion

intern:acos(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

ermittelt den Arkuskosinus (im Bogenmaß)

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der intern:acos()-Funktion

xsb:atan(1) as="xs:anyAtomicType" (xsl:function)

ermittelt den Arkustangens (im Bogenmaß)

Problematisch ist das Verhalten bei +/-Pi div 2 mit den "richtigen" Ergebnissen -INF resp. INF. Der XPath-3.0-Entwurf erwartet hier nur "sehr große" resp. "sehr kleine" Zahlen, die jetzt auch geliefert werden (was vielleicht auch den Vorteil, innerhalb von xs:decimal ohne Abbruch weiter rechnen zu können). Allerdings könnte sich dieses Verhalten im endgültigen Standard noch ändern, so dass diese Funktion später noch verändert werden könnte.

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der xsb:atan()-Funktion

intern:atan(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

ermittelt den Arkustangens (im Bogenmaß)

Revision History
Revision 0.2.352011-06-26Stf

Status: beta

Verhalten bei Sonderfällen an XSLT 3.0 angepasst (NaN, INF, -0.0e0)

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Argument der intern:atan()-Funktion

intern:atan-iterator(6) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

Iteration zur Ermittlung des Arkustangens

Der Algorithmus folgt http://mathworld.wolfram.com/InverseTangent.html, Gleichungen Nr. 44 bis 48.

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument (numerischer Wert)

Parameter an as="xs:anyAtomicType"

zur Übergabe des Ergebnisses aus der vorherigen Iteration, wird mit intern:pow(1 + ($arg * $arg), -0.5 ) initialisiert

Parameter bn as="xs:anyAtomicType"

zur Übergabe des Ergebnisses aus der vorherigen Iteration, wird mit 1 initialisiert

Parameter konstanterDivisor as="xs:anyAtomicType"

zur Optimierung, wird mit intern:sqrt(1 + ($arg * $arg) ) initialisiert

Parameter letztesResultat as="xs:anyAtomicType"

zur Ermittlung des Iteration-Abbruches, wird mit einem beliebigen Wert wie 0 initialisiert.

Parameter iteration as="xs:integer"

Zähler für Anzahl der Iterationen; wird mit 0 initialisiert

xsb:atan2(2) as="xs:anyAtomicType" (xsl:function)

berechnet atan2(y, x) im Bogenmaß

Bei Nullwerten wird ein Ergebnis entsprechend dem kommenden XPath-3.0-Standard zurückgegeben.

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter y as="xs:anyAtomicType"

y-Wert (numerisch)

Parameter x as="xs:anyAtomicType"

x-Wert (numerisch)

intern:atan2(2) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet atan2(y, x) im Bogenmaß

Bei Nullwerten wird ein Ergebnis entsprechend dem kommenden XPath-3.0-Standard zurückgegeben.

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter y as="xs:anyAtomicType"

y-Wert (numerisch)

Parameter x as="xs:anyAtomicType"

x-Wert (numerisch)

xsb:sgn(1) as="xs:anyAtomicType" (xsl:function)

gibt je nach Vorzeichen und Wert des Arguments -1, 0 oder +1 zurück

Im Unterschied zu intern:sgn() wird bei 0 der Wert 0 zurückgegeben: Werte kleiner 0 ergeben -1, Werte gleich 0 ergeben 0 und Werte größer 0 ergeben +1.

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument, numerischer Wert

intern:sgn(1) as="xs:anyAtomicType" (xsl:function)

gibt je nach Vorzeichen des Arguments -1 oder +1 zurück

Im Unterschied zu xsb:sgn() wird bei 0 ein positiver oder negativer Wert zurückgegeben: Werte kleiner 0 und -0.0e0 ergeben -1, Werte größer 0 und (+)0.0e0 ergeben +1.

Revision History
Revision 0.2.342011-06-20Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument, numerischer Wert

xsb:is-NaN(1) as="xs:boolean" (xsl:function)

testet, ob ein numerischer Wert NaN ist

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

xsb:is-INF(1) as="xs:boolean" (xsl:function)

testet, ob ein numerischer Wert INF ist

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

xsb:is-negative-INF(1) as="xs:boolean" (xsl:function)

testet, ob ein numerischer Wert -INF ist

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

xsb:is-negative-0(1) as="xs:boolean" (xsl:function)

testet, ob ein numerischer Wert -0.0e0 ist

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

intern:cast-NaN(1) as="xs:anyAtomicType" (xsl:function)

erzeugt NaN mit dem Typ des übergebenen Arguments

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

intern:cast-INF(1) as="xs:anyAtomicType" (xsl:function)

erzeugt INF mit dem Typ des übergebenen Arguments

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

intern:cast-negative-INF(1) as="xs:anyAtomicType" (xsl:function)

erzeugt -INF mit dem Typ des übergebenen Arguments

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

intern:cast-negative-0(1) as="xs:anyAtomicType" (xsl:function)

erzeugt -0.0e0 mit dem Typ des übergebenen Arguments

Revision History
Revision 0.2.372011-06-26Stf

Status: beta

initiale Version

Parameter arg as="xs:anyAtomicType"

Funktionsargument

xsb:is-in-range(3) as="xs:boolean" (xsl:function)

überprüft, ob ein numerischer Wert innerhalb eines Wertebereiches liegt

Wenn value die Leersequenz, NaN oder kein numerischer Wert ist, wird false() zurückgegeben. Zur Bequemlichkeit wird value auf xs:double gecastet, so dass auch (numerische) Strings verglichen werden können.

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter value as="xs:anyAtomicType?"

zu testender Wert

Parameter minInclusive as="xs:anyAtomicType"

untere Grenze

Parameter maxInclusive as="xs:anyAtomicType"

obere Grenze

xsb:variance(1) as="xs:anyAtomicType" (xsl:function)

berechnet aus einer Folge von numerischen Werten die Stichprobenvarianz

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter sequence_of_numeric_values as="xs:anyAtomicType+"

Eingabewerte, Sequenz von atomaren numerischen Werten

intern:variance(1) as="xs:anyAtomicType" (xsl:function)

berechnet aus einer Folge von numerischen Werten die Stichprobenvarianz

Der Algorithmus wird unter http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Compensated_variant beschrieben.

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter sequence_of_numeric_values as="xs:anyAtomicType+"

Eingabewerte, Sequenz von atomaren numerischen Werten

xsb:standard-deviation(1) as="xs:anyAtomicType" (xsl:function)

berechnet die Standardabweichung einer Stichprobe als Quadratwurzel der Varianz

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter sequence_of_numeric_values as="xs:anyAtomicType+"

Eingabewerte, Sequenz von atomaren numerischen Werten

intern:standard-deviation(1) as="xs:anyAtomicType" intern:solved="MissingTests" (xsl:function)

berechnet die Standardabweichung einer Stichprobe als Quadratwurzel der Varianz

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter sequence_of_numeric_values as="xs:anyAtomicType+"

Eingabewerte, Sequenz von atomaren numerischen Werten

intern:linear-congruential-generator(2) as="xs:integer+" (xsl:function)

linearer Kongruenzgenerator, erzeugt Pseudo-Zufallszahlen

Die erzeugten Werte liegen zwischen 0 und 4294967295.

Die Länge der erzeugten Sequenz ist die Anzahl der Werte in vortrag minus 1 plus length.

Für Details siehe http://de.wikipedia.org/wiki/Kongruenzgenerator#Linearer_Kongruenzgenerator und http://en.wikipedia.org/wiki/Linear_congruential_generator.

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter length as="xs:integer"

Anzahl der neu zu erzeugende Werte

Parameter vortrag as="xs:integer+"

Hilfsparameter für die rekursive Erzeugung der Sequenz. Beim Aufruf der Funktion wird hier der Seed-Wert übergeben, bei weiteren Durchläufen werden neu generierte angehängt. Bei Rückgabe der Seguenz wird der erste Wert (Seed) entfernt.

intern:random-max as="xs:integer" (xsl:variable)

intern:random-seed(1) as="xs:integer" intern:solved="MissingTests" (xsl:function)

erzeugt eine Zufallszahl

In die Berechnung der Zufallszahl gehen das aktuelle Datum und die aktuelle Uhrzeit sowie der volatile-Parameter ein.

Auch unabhängig vom Wert von volatile werden bei jedem Aufruf neue zufällige Werte erzeugt, allerdings 1) vermindert ein möglichst zufälliger volatile-Wert die Vorhersagbarkeit des Ergebnisses und 2) verhindert ein wechselnder volatile-Wert bei wiederholten Aufrufen der Funktion, dass der XSLT-Prozessor die unterschiedlichen Rückgabewerte qua Optimierung zu einem Wert vereinheitlicht.

Zum Hintergrund siehe http://blog.expedimentum.com/2012/xsb-random-zufallszahlen-mit-xslt/.

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter volatile as="xs:anyAtomicType"

ein möglichst zufälliger, veränderlicher Wert, der bei jedem Aufruf der Funktion verändert werden sollte

intern:random-sequence(2) as="xs:integer+" intern:solved="MissingTests" (xsl:function)

erzeugt eine Sequenz von zufälligen Werten im Bereich von 0 bis 4294967295.

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter length as="xs:integer"

Anzahl der zu erzeugenden Zufallswerte

Parameter volatile as="xs:anyAtomicType"

ein möglichst zufälliger, veränderlicher Wert, der bei jedem Aufruf der Funktion verändert werden sollte, z.B. string(.), count(preceding-sibling::*) o.ä., dabei ist es wichtig, das sich dieser Wert bei jedem Aufruf der Funktion ändert, weniger der Wert oder die Länge. Zum Hintergrund siehe http://blog.expedimentum.com/2012/xsb-random-zufallszahlen-mit-xslt/.

xsb:random(1) as="xs:decimal" intern:solved="MissingTests" (xsl:function)

erzeugt eine Zufallszahl im Bereich zwischen 0 und 1

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter volatile as="xs:anyAtomicType"

ein möglichst zufälliger, veränderlicher Wert, der bei jedem Aufruf der Funktion verändert werden sollte, z.B. string(.), count(preceding-sibling::*) o.ä., dabei ist es wichtig, das sich dieser Wert bei jedem Aufruf der Funktion ändert, weniger der Wert oder die Länge. Zum Hintergrund siehe http://blog.expedimentum.com/2012/xsb-random-zufallszahlen-mit-xslt/.

xsb:random-sequence(2) as="xs:decimal+" intern:solved="MissingTests" (xsl:function)

erzeugt eine Sequenz von Pseudo-Zufallszahlen im Bereich zwischen 0 und 1

Revision History
Revision 0.2.402012-01-04Stf

Status: beta

initiale Version

Parameter length as="xs:anyAtomicType"

Anzahl der zu erzeugenden Zufallswerte

Parameter volatile as="xs:anyAtomicType"

ein möglichst zufälliger, veränderlicher Wert, der bei jedem Aufruf der Funktion verändert werden sollte, z.B. string(.), count(preceding-sibling::*) o.ä., dabei ist es wichtig, das sich dieser Wert bei jedem Aufruf der Funktion ändert, weniger der Wert oder die Länge. Zum Hintergrund siehe http://blog.expedimentum.com/2012/xsb-random-zufallszahlen-mit-xslt/.

xsb:integer-to-hex(1) as="xs:string" (xsl:function)

Diese Funktion wandelt Integer- in Hexadezimalzahlen um. Negative Zahlen werden mit einem vorangestellten - (Minus) ausgegeben

Beispiele

  • xsb:integer-to-hex(0) ergibt »0«

  • xsb:integer-to-hex(10) ergibt »A«

  • xsb:integer-to-hex(-10) ergibt »-A«

  • xsb:integer-to-hex(-65535) ergibt »-FFFF«

Revision History
Revision 0.2.492012-05-19Stf

Status: beta

initiale Version

Parameter input as="xs:integer"

Integer-Zahl

xsb:integer-to-hex(2) as="xs:string" (xsl:function)

Diese Funktion wandelt Integer- in Hexadezimalzahlen um. Negative Zahlen werden im Zweierkomplement ausgegeben.

Je angefangene vier Bit wird eine Hexadezimalstelle ausgegeben.

Wenn $input nicht mit der gegebenen Anzahl Bits darstellbar ist, wird ein Fehler ausgegeben und die Verarbeitung abgebrochen.

Beispiele

  • xsb:integer-to-hex(10, 8) ergibt »0A«

  • xsb:integer-to-hex(-24, 8) ergibt »E8«

  • xsb:integer-to-hex(-1, 64) ergibt »FFFFFFFFFFFFFFFF«

  • xsb:integer-to-hex(128, 8) ergibt einen Fehler

Revision History
Revision 0.2.492012-05-19Stf

Status: beta

initiale Version

Parameter input as="xs:integer"

Integer-Zahl

Parameter n as="xs:integer"

Anzahl der Bits für Formatierung

xsb:twos-complement(2) as="xs:integer" (xsl:function)

ermittelt das Zweierkomplement

Wenn $input nicht mit der gegebenen Anzahl Bits darstellbar ist, wird ein Fehler ausgegeben und die Verarbeitung abgebrochen.

Beispiele

  • xsb:twos-complement(0, 8) ergibt »0«

  • xsb:twos-complement(-64, 8) ergibt »192«

  • xsb:twos-complement(-64, 64) ergibt »18446744073709551552«

  • xsb:twos-complement(128, 8) führt zum Abbruch

  • xsb:twos-complement(-129, 8) führt zum Abbruch

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

initiale Version

Parameter input as="xs:integer"

Integer-Zahl

Parameter n as="xs:integer"

Anzahl Bits für das Zeierkomplement

xsb:reverse-twos-complement(2) as="xs:integer" (xsl:function)

ermittelt aus einem Zweierkomplement einen Integer

Wenn $input nicht mit der gegebenen Anzahl Bits darstellbar ist, wird ein Fehler ausgegeben und die Verarbeitung abgebrochen.

Beispiele

  • xsb:reverse-twos-complement(0, 8) ergibt »0«

  • xsb:reverse-twos-complement(255, 8) ergibt »-1«

  • xsb:reverse-twos-complement(192, 8) ergibt »-64«

  • xsb:reverse-twos-complement(-1, 8) führt zum Abbruch

  • xsb:reverse-twos-complement(192, 4) führt zum Abbruch

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

initiale Version

Parameter input as="xs:integer"

Integer-Zahl

Parameter n as="xs:integer"

Anzahl Bits für das Zeierkomplement

xsb:hex-to-integer(2) as="xs:integer" (xsl:function)

wandelt Hexadezimalzahlen im Zweierkomplement in Integer-Zahlen um.

Wenn $input nicht mit der gegebenen Anzahl Bits darstellbar ist, wird ein Fehler ausgegeben und die Verarbeitung abgebrochen.

Eine andere Version dieser Funktion, die negative Zahlen mit Minus-Vorzeichen darstellt, findet sich in numbers.xsl

Beispiele

  • xsb:hex-to-integer('0', 8) ergibt »0«

  • xsb:hex-to-integer('1', 8) ergibt »1«

  • xsb:hex-to-integer('A', 8) ergibt »10«

  • xsb:hex-to-integer('FF', 8) ergibt »-1«

  • xsb:hex-to-integer('E8', 8) ergibt »-24«

  • xsb:hex-to-integer('ffee', 8) führt zum Abbruch

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

initiale Version

Parameter input as="xs:string"

eine hexadezimale Zahl (beliebige Folge aus 0-9 und A-F bzw. a-f)

Parameter n as="xs:integer"

Anzahl Bits für das Zeierkomplement

7. StyleCheck - internals.stylecheck.xsl

Path: internals.stylecheck.xsl

Import statements:

$Revision: 37 $, $Date: 2011-06-26 22:53:01 +0200 (Sun, 26 Jun 2011) $

Dieses Stylesheet enthält interne Templates und Funktionen, um XSLT-Dateien auf gängige Probleme zu testen.

Eine Spezialität dieses Stylesheets sind die intern:solved-Attribute. Sie können Token enthalten, die Stylesheet-Elemente von Tests ausschließen.

Verwendung

Für den Stylesheet-Test wird die zu testende XSLT-Datei mit dem Template intern:internals.Stylecheck transformiert. Anders formuliert: das Eingabedokument der Transformation ist die zu testende XSLT-Datei und das Stylesheet ein Test-XSLT, das das Template intern:internals.Stylecheck aufruft. Anwendungsbeispiele finden sich in den Test-Stylesheet der XSLT-SB wie z.B. strings_tests.xsl. Die Verwendung von Stylecheck ist dem Einsatz der Testumgebung ähnlich und erfolgt innerhalb der XSLT-SB meist gemeinsam, so dass bei Fragen ggfs. auch ein Blick dorthin lohnt.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.272011-05-30Stf

Status: beta

intern:internals.Stylecheck.CheckMisplacedIntern hinzugefügt

Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1392011-04-24Stf
Justierung der Fehlerlevel
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.1142010-07-18Stf
Dokumentation ausgebaut
Revision 0.932010-05-30Stf
Einbindung von internals.meta.xsl und Verwendung von intern:function-name(), Tests der arity bei intern:internals.Stylecheck.MissingTests
Revision 0.852010-04-10Stf
Einbindung von externen Test-Stylesheets
Revision 0.632009-11-22Stf
initiale Version

intern:internals.Stylecheck (xsl:template)

Dieses Template ist der zentrale Einstieg zur Realisierung der Style-Checks.

Es wird auf die zu untersuchende XSL-Datei und eventuelle Test-Stylesheets angewendet.

Test-Stylesheets beinhalten nur die Tests zu einem Stylesheet. Sie haben den selben Dateinamen wie das zu testende Stylesheet, ergänzt um _tests (Beispiel: "files.xsl" und "files_tests.xsl").

Es sind drei Fälle vorgesehen:

  1. Stylesheet und Tests in der selben Datei, Anwendung auf diese Datei.

  2. Stylesheet und Tests in getrennten Dateien, Anwendung auf Stylesheet-Datei

  3. Stylesheet und Tests in getrennten Dateien, Anwendung auf Test-Datei

Schwerwiegende Fehler werden mit Level »WARN« ausgegeben, Hinweise mit Level »INFO«

Revision History
Revision 0.852010-04-10Stf

Status: beta

Einbindung von externen Test-Stylesheets

Revision 0.632009-11-22Stf

Status: beta

initiale Version

intern:internals.Stylecheck.CallTemplateTestFunction (xsl:template)

Dieses Template überprüft die Syntax von Funktionstests mit xsl:call-template name="xsb:internals.test.Function".

Konkret getestet wird, ob der Inhalt der Parameter caller und actual-value übereinstimmt (weil sonst falsche, verwirrende Fehlermeldungen angezeigt werden.)

solved-Token: "CallTemplateTestFunction"

Revision History
Revision 0.632009-11-22Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.CallTemplateTestFunctionWithTestItem (xsl:template)

Dieses Template testet den Aufruf von Funktionstests mit xsb:internals.test.function.withTestItem.BooleanResult", xsb:internals.test.function.withTestItem.StringResult" usw..

solved-Token: "CallTemplateTestFunction"

Revision History
Revision 0.632009-11-22Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.MissingTypes (xsl:template)

Dieses Template testet, ob alle Variablen, Parameter und Funktionen getypt sind.

solved-Token: "MissingTypes"

Revision History
Revision 0.2.82011-05-14Stf

Status: beta

Typung von Funktionen hinzugefügt

Revision 0.632009-11-22Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.EmptySequenceAllowed (xsl:template)

Dieses Template testet, ob Funktionen oder Templates eine empty sequence als Resultat liefern dürfen.

Hintergrund: Funktionen und Templates sollten einen definierten Rückgabewert haben, also z.B. "0" oder den Leerstring ("") statt einer Leersequenz. Damit werden Typ-Fehler im aufrufenden Code reduziert.

solved-Token: "EmptySequenceAllowed"

Revision History
Revision 0.632009-11-22Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.MissingTests (xsl:template)

Dieses Template testet, ob alle Funktionen mit Test versehen sind.

solved-Token: "MissingTests"

Revision History
Revision 0.702009-13-08Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.RequiredParameter (xsl:template)

Dieses Template testet, ob bei Template-Parametern das required-Attribute gesetzt ist.

solved-Token: "RequiredParameter"

Revision History
Revision 0.632009-11-22Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.DocumentationTests (xsl:template)

Dieses Template testet verschiedene Aspekte der Qualität der Dokumentation.

Die Dokumentation mit XSLStyle™ und DocBook wird in standard.html erläutert.

solved-Token: "DocTest"

Revision History
Revision 0.2.272011-05-30Stf

Status: beta

Solved-Token "DocTest" hinzugefügt

Revision 0.2.112011-05-15Stf

Status: beta

Test auf @xml:id hinzugefügt

Revision 0.1112010-07-11Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.ListTO_DOs (xsl:template)

Dieses Template listet Texte und Kommentare, die "TODO" enthalten. Die Groß-/Kleinschreibung wird nicht berücksichtigt.

solved-Token: "ListTO_DOs"

Revision History
Revision 0.652009-11-29Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.CheckMisplacedIntern (xsl:template)

tested, ob im Stylesheet intern:*-Elemente innerhalb von matching oder named templates stehen, da diese fälschlicherweise in das Ausgabedokument geschrieben werden könnten.

solved-Token: "MisplacedIntern" (kann am Element selbst oder an einem Eltern-Element stehen)

Revision History
Revision 0.2.272011-05-30Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

intern:internals.Stylecheck.CheckXSLMessage (xsl:template)

tested, ob im Stylesheet xsl:message-Elemente verwendet werden.

Wegen der höheren Flexibilität bietet sich die Verwendung des Logging-Systems an. Innerhalb der Stylesheets der XSLT-SB soll xsl:message nur in Ausnahmefällen verwendet werden.

solved-Token: "CheckXSLMessage" (kann am Element selbst stehen)

Revision History
Revision 0.2.362011-06-26Stf

Status: beta

initiale Version

Parameter Dokument as="document-node()" required="yes"

XSL-Dokument-Knoten, auf den die Tests angewendet werden.

match="/" mode="internals.self-test" (xsl:template)

Dieses Template ist der Einstiegspunkt in die Selbst-Tests. Es loggt die Systemparameter und ruft die Test-Routinen der lokalen und eingebundenen Templates und Funktionen auf.

intern:internals.stylecheck.self-test (xsl:template)

Dieses Template führt die lokalen Selbst-Tests aus.

Revision History
Revision 0.632009-11-22Stf

Status: beta

initiale Version

8. Meta-Funktionen - internals.meta.xsl

Path: internals.meta.xsl

$Revision: 25 $, $Date: 2011-05-22 01:49:34 +0200 (Sun, 22 May 2011) $

Dieses Stylesheet enthält interne Templates und Funktionen zur Untersuchung von XSLT-Dateien.

Sie sind das Ergebnis von ein paar Experimenten zur Analyse von Stylesheets und sehr, sehr alpha.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.932010-05-30Stf
initiale Version, ausgelagert aus internals.stylecheck.xsl

intern:function-name(1) as="xs:string" (xsl:function)

ermittelt den Namen einer Funktion aus einem String, der wie eine Funktion aussieht

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe eines ungültigen Strings gibt einen Leerstring zurück.

Revision History
Revision 0.932010-05-30Stf

Status: alpha

initiale Version

Parameter StringOfAFunctionCall as="xs:string?"

String, der wie ein Funktionsaufruf aussieht.

intern:function-arity(1) as="xs:integer" (xsl:function)

ermittelt die Arity (d.h. die Anzahl der Argumente) einer Funktion

Die Eingabe eines Leerstringes gibt 0 zurück.

Die Eingabe eines ungültigen Strings gibt 0 zurück.

Revision History
Revision 0.932010-05-30Stf

Status: alpha

initiale Version

Parameter StringOfAFunctionCall as="xs:string?"

String, der wie ein Funktionsaufruf aussieht.

intern:looks-like-a-function-call(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft eine String darauf, ob er wie der Aufruf einer XSLT-/Xpath-Funktion aussieht. Es werden nur zwei Dinge getestet:

  1. per regulärem Ausdruck wird geprüft, ob der String aus einem Namen + einem geklammerten Ausdruck besteht und

  2. per Simulation von castable as xs:Name wird geprüft, ob der vermeintliche Funktionsname ein XML-Name ist. Die Simulation ist notwendig, weil der Typ xs:Name nicht von einem Basic-XSLT-Prozessor unterstützt wird.

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe eines ungültigen Strings gibt false() zurück.

Revision History
Revision 0.932010-05-30Stf

Status: alpha

initiale Version

Parameter StringOfAFunctionCall as="xs:string?"

String, der wie ein Funktionsaufruf aussieht.

intern:castable-as-xs-name(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft eine String darauf, ob er als xs:Name gecastest werden kann. Diese Funktion ist notwendig, weil xs:Name resp. castable as xs:Name nicht von einem Basic-XSLT-Prozessor unterstützt werden.

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe eines ungültigen Strings gibt false() zurück.

Revision History
Revision 0.952010-06-28Stf

Status: alpha

initiale Version

Parameter string as="xs:string?"

String, der geprüft werden soll.

intern:castable-as-xs-ncname(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft eine String darauf, ob er als xs:NCName gecastest werden kann. Die Überprüfung erfolgt an Hand eines regulären Ausdruckes nach http://www.w3.org/TR/REC-xml/#NT-Name.

Diese Funktion ist notwendig, weil xs:NCName resp. castable as xs:NCName nicht von einem Basic-XSLT-Prozessor unterstützt werden.

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe eines ungültigen Strings gibt false() zurück.

Revision History
Revision 0.952010-06-28Stf

Status: alpha

initiale Version

Parameter string as="xs:string?"

String, der geprüft werden soll.

intern:function-argument-string(1) as="xs:string" (xsl:function)

Diese Funktion gibt aus einem String, der wie ein Funktionsaufruf aussieht, einen String der vermeintlichen Argumente zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe eines ungültigen Strings (d.h. der String sieht nicht wie eine Funktion aus) gibt einen Leerstring zurück.

Revision History
Revision 0.932010-05-30Stf

Status: alpha

initiale Version

Parameter StringOfAFunctionCall as="xs:string?"

String, der wie ein Funktionsaufruf aussieht.

intern:function-arguments(1) as="xs:string*" intern:solved="EmptySequenceAllowed" (xsl:function)

Diese Funktion erzeugt eine Sequence von Strings der Argumente aus einem String, der wie eine Funktion aussieht.

Die Eingabe eines Leerstringes gibt eine Leersequenz zurück.

Die Eingabe eines ungültigen Strings (d.h. der String sieht nicht wie eine Funktion aus) gibt eine Leersequenz zurück (um <xsl:for-each/> effektiv nutzen zu können).

Revision History
Revision 0.932010-05-30Stf

Status: alpha

initiale Version

Parameter StringOfAFunctionCall as="xs:string?"

String, der wie ein Funktionsaufruf aussieht.

intern:replace-nested-brackets-with-dashes(1) as="xs:string" (xsl:function)

Diese Funktion ist eine Hilfsfunktion, die nur existiert, weil rekursive Aufrufe notwendig waren. Details sind nicht interssant.

Die Eingabe eines Leerstringes oder eine Leersequenz gibt einen Leerstring zurück.

Revision History
Revision 0.1162010-07-21Stf

Status: alpha

initiale Version

Parameter input as="xs:string?"

String, der wie ein Funktionsargument aussieht (wird nicht validiert).

9. Testen von Stylesheets - internals.testing.xsl

Path: internals.testing.xsl

Import statement:

$Revision: 34 $, $Date: 2011-06-20 22:05:11 +0200 (Mon, 20 Jun 2011) $

Dieses Stylesheet enthält interne Templates und Funktionen zum Testen von XSLT-Stylesheets.

Grundidee ist, einzelne Funktionen und Templates mit definierten Argumenten aufzurufen und die Rückgabewerte mit erwarteten Werten zu vergleichen. Dieses Stylesheet stellt Funktionen und Templates bereit, die diesen Prozess vereinfachen.

Ein einzelner Test besteht aus dem Aufruf einer Funktion bzw. eines Templates und dem Vergleich des Ergebnisses mit einem Vorgabewert. Üblicherweise wird man mehrere Tests in einem Test-Template zusammenfassen, das dann unabhängig vom zu testenden Stylesheet aufgerufen wird.

Test-Templates können in das zu testende Stylesheet selbst oder in externe Test-Stylesheets eingebunden werden.

Vorteile interner Tests sind:

  • Tests sind unmittelbar mit dem zu testenden Code in einer Datei verbunden.

  • Tests können schnell und unkompliziert beim Entwickeln erstellt und ausgeführt werden.

Vorteile externer Tests sind:

  • Stylesheets werden kleiner
  • Fehler in den Tests führen nicht zu Fehlern im Stylesheet

  • Die Test-Stylesheets werden aus der Stylesheet-Hierarchie ausgekoppelt. Deshalb können für die Tests Stylesheets eingebunden werden, die aufgrund der Stylesheet-Hierarchie (zirkuläres <xsl:include/>/<xsl:import/>) nicht in das zu testende Stylesheet selbst eingebunden werden können. Ein Beispiel dafür ist strings.xsl, das (über internals.xsl und internals.logging.xsl) in internals.testing.xsl eingebunden wird. Die Tests für strings.xsl wurden deshalb nach strings_tests.xsl ausgelagert.

In der XSLT-SB kommen beide Techniken zum Einsatz, wobei es keine festen Regeln gibt. In der Praxis wird man meist mit Tests innerhalb des Stylesheets anfangen und diese bei einem bestimmten Umfang oder bei Abschluss der Entwicklung auslagern.

Wegen der engen Verknüpfung der Test-Infrastruktur mit internals.Stylecheck (welches das zu testenden Stylesheet als Eingabedokument erwartet) werden innerhalb der XSLT-SB die Tests durch eine Transformation des zu testenden Stylesheets mit dem Test-Stylesheet (das im Fall interner Test-Templates das zu testende Stylesheet selbst ist) im Mode internals.self-test ausgeführt. Externe Test-Stylesheets müssen wegen dieser Verknüfung nach dem Namensschema xxxxx_tests.xsl (wobei »xxxxx« für den Namen – ohne Erweiterung – des zu testenden Stylesheets steht) benannt werden. Verzichtet man auf den Einsatz von Stylecheck, können die Tests in beliebigen XSLT-Dateien abgelegt werden.

Die Verwendung der Testumgebung ist dem Einsatz von Stylecheck ähnlich und erfolgt innerhalb der XSLT-SB meist gemeinsam, so dass bei Fragen ggfs. auch ein Blick dorthin lohnt.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.822010-03-28Stf
initiale Version, ausgelagert aus internals.xsl

_internals.testing.current-vendor-hash as="xs:string" select="xsb:current-vendor-hash()" (xsl:variable)

Hilfsvariable, da dieser Wert häufig benötigt wird.

xsb:internals.test.Function (xsl:template)

Dieses Template dient zum Testen einer Funktion. Es nimmt den Namen der Funktion sowie Ist- und Soll-Wert entgegen und vergleicht sie. Je nach Ergebnis wird ein Bericht an das Logging-System ausgegeben.

Revision History
Revision 0.2.342011-06-26Stf

Status: beta

Fehlerausgabe: Typ bei xs:anyAtomicValue ergänzt

Revision 0.572009-10-25Stf

Status: beta

initiale Version

Parameter caller as="xs:string" required="yes"

aufrufende Funktion, wenn möglich inklusive der konkreten Parameter

Parameter actual-value required="yes"

Ergebnis der getesteten Funktion. Im select-Attribut des <xsl:with-param/>-Elements sollte die Funktion aufgerufen werden.

Parameter reference-value required="yes"

erwarteter Rückgabewert der getesteten Funktion

xsb:internals.test.function.withTestItem.BooleanResult (xsl:template)

Dieses Template unterstützt das Testen von Funktionen mit Testlisten, indem es einen Testknoten für das Template xsb:internals.test.Function aufbereitet.

Manchmal sollen mehrere Funktionen mit einer größeren Anzahl von Parametern getestet werden. Ein Beispiel sind die Tests für files.xsl, wo die meisten Funktionen gegen Dutzende gültige und ungültige URLs geprüft werden. Test-Knoten und die Templates xsb:internals.test.function.withTestItem.BooleanResult, xsb:internals.test.function.withTestItem.StringResult und xsb:internals.test.function.withTestItem.NumericResult vereinfachen solche Massentests.

Grundidee ist, in einer Liste von Testknoten jeweils Funktionsargumente und erwartetes Ergebnis abzulegen. Eine <xsl:for-each/>-Schleife kann dann über die Sequenz der Testknoten gehen, das Funktionsergebnis berechnen, es mit dem Vorgabewert vergleichen und positive und negative Ergebnisse loggen. Testknoten und internals.test.function.withTestItem…-Templates implementieren dafür eine Infrastruktur.

Ein Testknoten ist ein Element (der Name ist egal), das mindestens zwei Kind-Elemente haben muss: eine Element mit dem Namen value, und ein Element mit dem qualifizierten Namen der zu testenden Funktion (das Test-Item). Mehrere Testknoten können in einer Testliste (Name ist wieder egal) zusammengefasst werden. Da Kinder von <xsl:stylesheet/> in einem beliebigen Namensraum ignoriert werden, kann man die Liste dort ablegen. Ein Beispiel:

<intern:testliste>
	<test>
		<value>file:///server/path/test.txt</value>
		<xsb:is-absolute-url>true</xsb:is-absolute-url>
		<xsb:fileName-and-fileExtention-from-url>test.txt</xsb:fileName-and-fileExtention-from-url>
	</test>
	<test>
		<value>file:///server/path/test.txt/test</value>
		<xsb:is-absolute-url>true</xsb:is-absolute-url>
		<xsb:fileName-and-fileExtention-from-url>test</xsb:fileName-and-fileExtention-from-url>
	</test>
</intern:testliste>
		

Diese Testliste besteht aus zwei Testknoten. Jeder Testknoten hat ein <value/>-Element, dessen Inhalt (beim ersten Testkonten also »file:///server/path/test.txt«) von den Testroutinen als Parameter benutzt wird. In den beiden Test-Items <xsb:is-absolute-url/> und <xsb:fileName-and-fileExtention-from-url/> stehen die erwarteten Ergebnisse, wobei true von xsb:internals.test.function.withTestItem.BooleanResult als Wahrheitswert geparst und test.txt von xsb:internals.test.function.withTestItem.StringResult als String interpretiert wird. Die eigentliche Testroutine nimmt eine Sequenz von Testknoten und gibt diese einzeln an die Test-Templates weiter, etwa so:

<xsl:for-each select="document( '' )//intern:testliste/test">
	<xsl:call-template name="xsb:internals.test.function.withTestItem.BooleanResult">
		<xsl:with-param name="test-node" select="."/>
		<xsl:with-param name="function-name">xsb:is-absolute-url</xsl:with-param>
		<xsl:with-param name="actual-value" select="xsb:is-absolute-url(./value/text())"/>
	</xsl:call-template>
	<xsl:call-template name="xsb:internals.test.function.withTestItem.StringResult">
		<xsl:with-param name="test-node" select="."/>
		<xsl:with-param name="function-name">xsb:fileName-and-fileExtention-from-url</xsl:with-param>
		<xsl:with-param name="actual-value" select="xsb:fileName-and-fileExtention-from-url(./value/text())"/>
	</xsl:call-template>
</xsl:for-each>
		

Die internals.test.function.withTestItem…-Templates nehmen einen Testknoten (im Template-Parameter test-node) und einen aktuellen Wert (im Template-Parameter actual-value) entgegen. Der Testknoten hat ein Kindelement mit dem Namen der zu testenden Funktion, das das erwartete Resultat als Textknoten enthält. An Hand des Template-Parameters function-name wird dieses Kind-Element ausgewählt, in einen Wert vom gewünschten Typ (boolean, string) ungewandelt und mit actual-value verglichen. Das Ergebnis des Vergleichs – OK- oder Fehlermeldung – wird an das Logging-System übergeben.

Testknoten und Test-Items können für einen oder mehrere XSLT-Prozessoren ausgeschlossen werden. Dazu erhält der Testknoten oder das Test-Item ein intern:skip-Attribut, das eine leerzeichen-getrennte Liste der betreffenden Vendor-Hashs (siehe xsb:current-vendor-hash()) enthält. Auf betroffenen XSLT-Prozessoren wird der gesamte Testknoten oder das entsprechende Test-Item übersprungen und eine Warnung (per Template xsb:internals.testing.SkippedTests) ausgegeben.

Revision History
Revision 0.1452011-05-03Stf

Status: beta

intern:skip-Attribut eingebaut

Revision 0.782010-03-06Stf

Status: beta

ausgelagert aus files_temp_uri.xsl

Revision 0.702009-12-07Stf

Status: beta

initiale Version in files_temp_uri.xsl

Parameter test-node as="element()" required="yes"

Parameter function-name as="xs:string" required="yes"

Name der getesteten Funktion. Der Funktionsname wird sowohl zur Ermittlung des Referenzwertes aus dem Testknoten als auch zur Ausgabe der Resultate an das Logging-System verwendet.

Parameter actual-value as="xs:boolean" required="yes"

aktuelles Ergebnis der getesteten Funktion. Im select-Attribut des <xsl:with-param/>-Elements sollte die getestete Funktion mit dem Inhalt des <value/>-Elements des Testknotens als Argument aufgerufen werden.

xsb:internals.test.function.withTestItem.StringResult (xsl:template)

Dieses Template unterstützt das Testen von Funktionen mit Testlisten, indem es einen Testknoten für das Template xsb:internals.test.Function aufbereitet.

Revision History
Revision 0.1452011-05-03Stf

Status: beta

intern:skip-Attribut eingebaut

Revision 0.782010-03-06Stf

Status: beta

ausgelagert aus files_temp_uri.xsl

Revision 0.702009-12-07Stf

Status: beta

initiale Version in files_temp_uri.xsl

Parameter test-node as="element()" required="yes"

Parameter function-name as="xs:string" required="yes"

Name der getesteten Funktion. Der Funktionsname wird sowohl zur Ermittlung des Referenzwertes aus dem Testknoten als auch zur Ausgabe der Resultate an das Logging-System verwendet.

Parameter actual-value as="xs:string?" required="yes"

aktuelles Ergebnis der getesteten Funktion. Im select-Attribut des <xsl:with-param/>-Elements sollte die getestete Funktion mit dem Inhalt des <value/>-Elements des Testknotens als Argument aufgerufen werden.

xsb:internals.test.function.withTestItem.NumericResult (xsl:template)

Dieses Template unterstützt das Testen von Funktionen mit Testlisten, indem es einen Testknoten für das Template xsb:internals.test.Function aufbereitet.

Um bei Umwandlung und Vergleich der vermeintlich numerischen actual-value bzw. $test-node/value/text() einen Abbruch bei gescheiterten Cast auf z.B. xs:double zu vermeiden (wie es etwa bei einem Leerstring der Fall wäre), wird auf string gecastet und dann die String-Werte verglichen.

Revision History
Revision 0.0.252011-05-25Stf

Status: beta

cast von reference-value auf type von actual-value eingebaut

Revision 0.942010-05-30Stf

Status: beta

initiale Version

Parameter test-node as="element()" required="yes"

Parameter function-name as="xs:string" required="yes"

Name der getesteten Funktion. Der Funktionsname wird sowohl zur Ermittlung des Referenzwertes aus dem Testknoten als auch zur Ausgabe der Resultate an das Logging-System verwendet.

Parameter actual-value required="yes" as="xs:anyAtomicType"

aktuelles Ergebnis der getesteten Funktion. Im select-Attribut des <xsl:with-param/>-Elements sollte die getestete Funktion mit dem Inhalt des <value/>-Elements des Testknotens als Argument aufgerufen werden.

intern:validate-test-node(2) as="xs:boolean" intern:solved="MissingTests" (xsl:function)

Diese Funktion testet ein Element auf seine Eignung als Eingabe-Knoten für Funktionen wie xsb:internals.test.function.withTestItem.BooleanResult.

Revision History
Revision 0.822010-03-28Stf

Status: beta

initiale Version

Parameter test-node as="element()"

zu testender test-node

Parameter function-name as="xs:string"

qualifizierter Name der Funktion, für die $test-node das erwartete Testergebnis beinhalten soll.

xsb:internals.testing.SkippedTests (xsl:template)

Ausgabe einer Warnung für übersprungene Tests

Bestimmte Funktionen erfordern Erweiterungen wie JAVA oder prozessorspezifische Funktionen, d.h. sie arbeiten nicht mit allen XSLT-Prozessoren zusammen. Andere Funktionen scheitern an prozessorspezifischen Inkompatibilitäten.

Solche Tests müsen im Test-Template an Hand des Vendor-Hashs (siehe xsb:current-vendor-hash()) unterdrückt werden. Dies kann hart über eine xsl:if-Abfrage im Testtemplate oder einfacher über intern:skip-Attribute an Testknoten und Test-Items geschehen.

Dieses Template gibt in diesen Fällen eine standardisierte Meldung aus.

Ein Beispiel für die Verwendung (hart ausgeschlossen und per intern:skip-Attribut) findet sich in files_tests.xsl.

Revision History
Revision 0.1432011-04-26Stf

Status: beta

initiale Version

Parameter caller as="xs:string" required="yes"

Name und ggfs. arity der Funktion, für die der Test übersprungen wurde.

Parameter level as="xs:string" required="no"

Level für die Fehlerausgabe, Vorgabe: WARN

10. Dateien und Dateisystem - files.xsl

Path: files.xsl

Import statements:

$Revision: 41 $, $Date: 2012-03-24 21:59:50 +0100 (Sa, 24 Mrz 2012) $

Dieses Stylesheet enthält Funktionen rund um das Dateisystem.

Ein Großteil der Funktionen führt Formatchecks auf Strings aus und extrahiert Teile aus Strings, um den Umgang mit externe Dateien zu vereinfachen. Da der von XSLT präferierte Typ xs:anyURI recht unspezifisch ist, wird dabei auf URLs nach RFC 1808 zurückgegriffen.

Einige Wertebereiche und Funktionsergebnisse sind nicht absolut konform zu RFC 1808 oder auch RFC 3986 (URIs), um den praktischen Nutzen zu erhöhen. So ist beispielsweise laut RFC 1808 die Tilde (~) kein gültiges Zeichen in URLs, sie wurde hier aber zugelassen.

Autor: Stefan Krause

Homepage: http://www.expedimentum.org/

Lizenz (duale Lizenzierung):

Dieses Stylesheet und die dazugehörige Dokumentation sind unter einer Creative Commons-Lizenz (CC-BY 3.0) lizenziert. Die Weiternutzung ist bei Namensnennung erlaubt.

Dieses Stylesheet und die dazugehörige Dokumentation sind unter der sogenannten Expat License (einer GPL-kompatiblen MIT License) lizensiert. Es darf – als Ganzes oder auszugweise – unter Beibehaltung der Copyright-Notiz kopiert, verändert, veröffentlicht und verbreitet werden. Die Copyright-Notiz steht im Quelltext des Stylesheets und auf der Startseite der Dokumentation.

Revision History
Revision 0.2.412012-02-04Stf

Umstellung auf stylesheet-interne Tabelle und dadurch mehr Mediatypes und Extensions

Revision 0.2.02011-05-14Stf
erste veröffentlichte Version
Revision 0.1292011-02-27Stf
Erweiterung der Lizenz auf Expath/MIT license
Revision 0.1202010-07-26Stf
<xsl:value-of/> gegen <xsl:sequence/> ausgetauscht
Revision 0.802010-03-28Stf
Diverse Ergänzungen und BugFixes, v.a. um xsb:file-exist() zum Laufen zu bringen
Revision 0.742010-03-01Stf
Neudesign mit Java und Entity References, Saxon-spezifische Funktionen entfernt
Revision 0.532009-10-25Stf
Umstellung auf Namespaces xsb: und intern:
Revision 0.522009-10-13Stf
Anpassungen an unterschiedliche Saxon-Versionen
Revision 0.502009-10-11Stf
Start mit Testroutinen
Revision 0.362009-08-02Stf
Umstellung der Lizenz auf CC-BY 3.0
Revision 0.282009-05-03Stf
erste Version mit Dokumentation

xsb:is-absolute-url(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL absolut ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:is-relative-url(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL relativ ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt true() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:is-network-server-url(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL ausschließlich einen Netzwerk-Server referenziert, d.h. keinen lokalen Teil hat. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:url-has-authority(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL einen Authority-Teil hat. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.752010-03-18Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:is-path-only-url(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL ein Pfad ist, d.h. es wird durch die URL keine Datei referenziert. Kriterium ist, ob die URL entweder (a) einen Netzwerk-Server referenziert oder (b) mit "/", "/." oder "/.." endet oder (c) "." oder ".." ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:is-shortcut-only-url(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL nur aus Pfad-Shortcuts ("/", ".", "..") besteht. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:is-url(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob der eingegebene String eine gültige URL gemäß RFC 1808 ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt true() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Abweichend von den zugrundeliegenden Standards RFC 1808 und RFC 3986 werden bestimmte URLs nicht als gültig angesehen ("scheme" steht für URL-Schema):

  • scheme:

  • scheme:/

Revision History
Revision 0.802010-03-27Stf

Status: beta

Ausschluss standardkonformer, aber wenig hilfreicher URLs wie "scheme:"

Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:url-has-query(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL einen Query-Teil hat. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:query-from-url(1) as="xs:string" (xsl:function)

Diese Funktion gibt den Query-Teil von einer URL zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:url-has-fragment(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL einen Fragment-Teil (eine Referenz auf einen Dokumenten-Teil nach einem Hash-Zeichen #) hat. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:fragment-from-url(1) as="xs:string" (xsl:function)

Diese Funktion gibt den Fragment-Teil von einer URL zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:scheme-from-url(1) as="xs:string" (xsl:function)

Diese Funktion gibt den scheme-Teil von einer absoluten URL zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.752010-03-07Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:remove-query-and-fragment-from-url(1) as="xs:string" (xsl:function)

Diese Funktion entfernt Query- und Fragment-Teil von einer URL.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer Leersequenz gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:fileName-and-fileExtention-from-url(1) as="xs:string" (xsl:function)

Diese Funktion gibt Dateinamen und Dateierweiterung aus einer URL zurück.

Die Eingabe einer Server-URL oder eines Pfades gibt einen Leerstring zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:fileExtention-from-url(1) as="xs:string" (xsl:function)

Diese Funktion ermittelt eine eventuelle Dateierweiterung aus einer URL.

Da die Interpretation von Dateinamenserweiterungen sehr DOS/Windows-spezifisch ist, wird deren Interpretation nachvollzogen. Beispielsweise ist ".txt" (nur Erweiterung "txt") ein gültiger Dateiname für eine Textdatei.

Die Eingabe einer Server-URL oder eines Pfades gibt einen Leerstring zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Die Eingabe einer URL mit einem Dateinamen, der nur aus Punkt+Erweiterung besteht, gibt die Erweiterung zurück.

Revision History
Revision 0.852010-04-10Stf

Status: beta

Dateiname = Dateierweiterung berücksichtigt.

Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:url-has-fileExtention(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene URL einen Dateinamen beinhaltet, und ob dieser Dateiname eine Dateierweiterung hat. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Da die Interpretation von Dateinamenserweiterungen sehr DOS/Windows-spezifisch ist, wird deren Interpretation nachvollzogen. Beispielsweise ist ".txt" (nur Erweiterung "txt") ein gültiger Dateiname für eine Textdatei.

Die Eingabe eines Leerstringes gibt false() zurück.

Die Eingabe einer ungültigen URL gibt false() zurück.

Revision History
Revision 0.852010-04-10Stf

Status: beta

Dateiname = Dateierweiterung berücksichtigt.

Revision 0.832010-04-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:fileName-from-url(1) as="xs:string" (xsl:function)

Diese Funktion ermittelt einen Dateinamen ohne eventuelle Dateierweiterung aus einer URL.

Die Eingabe einer Server-URL oder eines Pfades gibt einen Leerstring zurück.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe eines Dateinamens, der nur aus Punkt+Dateierweiterung besteht (z.B. ".txt"), gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:path-from-url(1) as="xs:string" (xsl:function)

Diese Funktion ermittelt einen Pfad ohne eventuelle Dateinamen und Dateierweiterung aus einer URL.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Revision History
Revision 0.742010-01-03Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

String, der als URL interpretiert wird.

xsb:file-exists(1) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene Datei lokal vorhanden ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Es werden nur lokale Dateien mit absoluten URLs getestet. Dies impliziert, dass auch keine URLs mit einer authority bearbeitet werden können (hier hält sich die Funktion an die Vorgaben von Java), d.h. bei absoluten URLs, die nicht mit dem Protokoll-Teil file:/ oder file:/// beginnen, wird false() zurückgegeben.

Der Wertebereich für gültige Parameter wurde auf den kleinsten gemeinsamen Nenner der zu Grunde liegenden Funktionen eingegrenzt.

Achtung! Diese Funktion erfordert bei Ausführung Java oder Saxon-spezifische Erweiterungen.

Revision History
Revision 0.742010-01-03Stf

Status: alpha

initiale Version

Parameter absoluteURL as="xs:string?"

Absoluter Pfad zur zu überprüfenden Datei.

xsb:file-exists(2) as="xs:boolean" (xsl:function)

Diese Funktion überprüft, ob die angegebene Datei lokal vorhanden ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Die relative URL wird gegenüber der Basis aufgelöst. Es werden nur lokale Dateien getestet, d.h. beginnt die Basis nicht mit dem Protokoll file: oder verweist auf eine Ressource im Internet (= hat einen authority-Teil), wird false() zurückgegeben.

Achtung! Diese Funktion erfordert bei Ausführung Java oder Saxon-spezifische Erweiterungen.

Revision History
Revision 0.742010-01-03Stf

Status: alpha

initiale Version

Parameter relativeURL as="xs:string?"

relativer Pfad zur zu überprüfenden Datei.

Parameter baseURL as="xs:string?"

Basis für den relativen Pfad.

intern:file-exists(1) as="xs:boolean" use-when="function-available('java-file:exists')" intern:solved="MissingTests" (xsl:function)

Diese Funktion überprüft, ob die angegebene Datei lokal vorhanden ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Es werden nur lokale Dateien mit absoluten URLs getestet.

Achtung! Diese Funktion erfordert bei Ausführung Java.

Revision History
Revision 0.742010-01-03Stf

Status: alpha

initiale Version

Parameter absoluteURL as="xs:string?"

Absoluter Pfad zur zu überprüfenden Datei.

intern:file-exists(1) as="xs:boolean" use-when="not(function-available('java-file:exists')) and function-available( 'saxon:last-modified' ) and not(function-available( 'saxon:file-last-modified' ))" intern:solved="MissingTests" (xsl:function)

Diese Funktion überprüft, ob die angegebene Datei lokal vorhanden ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Achtung! Diese Funktion erfordert bei Ausführung die Saxon-spezifische Erweiterung saxon:last-modified(), die in Saxon-PE und Saxon-EE (aber nicht in Saxon-HE) ab Version 9.2 vorhanden sind.

Revision History
Revision 0.742010-01-03Stf

Status: alpha

initiale Version

Parameter absoluteURL as="xs:string?"

Pfad zur zu überprüfenden Datei

intern:file-exists(1) as="xs:boolean" use-when="not(function-available('java-file:exists')) and function-available( 'saxon:file-last-modified' ) and function-available( 'saxon:last-modified' )" intern:solved="MissingTests" (xsl:function)

Diese Funktion überprüft, ob die angegebene Datei lokal vorhanden ist. Das Ergebnis ist ein Wahrheitswert (xs:boolean, true() oder false()).

Achtung! Diese Funktion erfordert bei Ausführung die Saxon-spezifische Erweiterung saxon:file-last-modified(), die in Saxon-B und Saxon-SA bis einschließlich Version 9.1 vorhanden sind.

Revision History
Revision 0.742010-01-03Stf

Status: alpha

initiale Version

Parameter absoluteURL as="xs:string?"

Pfad zur zu überprüfenden Datei

intern:file-exists(1) as="xs:boolean" use-when="not(function-available('java-file:exists')) and not(function-available( 'saxon:file-last-modified' ) or function-available( 'saxon:last-modified' ) )" intern:solved="MissingTests" (xsl:function)

Diese Funktion wird aufgerufen, wenn weder Java noch Saxon-spezifische Funktionen vorhanden sind. In diesem Fall wird die Stylesheet-Verarbeitung abgebrochen, z.B. bei Saxon-B 8.9, Saxon-HE 9.2 und Intel 2.0.

Revision History
Revision 0.742010-01-03Stf

Status: alpha

initiale Version

Parameter absoluteURL as="xs:string?"

Pfad zur zu überprüfenden Datei

xsb:mediatype-from-url(2) as="xs:string" (xsl:function)

Diese Funktion ermittelt aus der Dateierweiterung den Mediatyp (auch MIME-Typ genannt).

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Die Eingabe einer ungültigen Dateierweiterung gibt einen Leerstring und – in Abhängigkeit von warn-if-wrong-input – ggfs. eine Warnung zurück.

Revision History
Revision 0.2.412012-02-04Stf

Status: beta

Umstellung auf stylesheet-interne Tabelle und dadurch mehr Mediatypes und Extensions

Revision 0.902010-04-23Stf

Status: beta

initiale Version

Parameter URLwithFileExtension as="xs:string?"

URL, aus dessen file extension der Mediatype ermittelt werden soll.

Parameter warn-if-wrong-input as="xs:boolean"

Soll eine Warnung ausgegeben werden, wenn der Mediatyp nicht ermittelt werden kann?

xsb:mediatype-from-url(1) as="xs:string" (xsl:function)

Shortcut für xsb:mediatype-from-url($URLwithFileExtension, true()).

Revision History
Revision 0.902010-04-23Stf

Status: beta

initiale Version

Parameter URLwithFileExtension as="xs:string?"

URL, aus dessen file extension der Mediatype ermittelt werden soll.

xsb:file-extension-from-mediatype(2) as="xs:string" (xsl:function)

Diese Funktion ermittelt aus dem Mediatyp (auch MIME-Typ genannt) die Dateierweiterung.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe eines ungültigen Mediatypes gibt einen Leerstring und – in Abhängigkeit von warn-if-wrong-input – ggfs. eine Warnung zurück.

Revision History
Revision 0.2.412012-02-04Stf

Status: beta

initiale Version

Parameter mediatype as="xs:string?"

Mediatype, aus dem die Dateierweiterung ermittelt werden soll.

Parameter warn-if-wrong-input as="xs:boolean"

Soll eine Warnung ausgegeben werden, wenn die Dateierweiterung nicht ermittelt werden kann?

xsb:file-extension-from-mediatype(1) as="xs:string" (xsl:function)

Shortcut für xsb:file-extension-from-mediatype($mediatype, true()).

Revision History
Revision 0.2.412012-02-04Stf

Status: beta

initiale Version

Parameter mediatype as="xs:string?"

Mediatype, aus dem die Dateierweiterung ermittelt werden soll.

xsb:decode-from-url(1) as="xs:string" (xsl:function)

wandelt Hex-codierte Zeichen in URLs in Zeichen um.

Die Eingabe eines Leerstringes gibt einen Leerstring zurück.

Die Eingabe einer ungültigen URL gibt einen Leerstring zurück.

Zeichen außerhalb des in URLs darstellbaren ASCII-Zeichenvorrats (Codepoints 127 oder kleiner 32) werden encodiert belassen.

Beispiele

  • xsb:decode-from-url('') ergibt den Leerstring

  • xsb:decode-from-url('file') ergibt »file«

  • xsb:decode-from-url('%3b%4f') ergibt »;O«

  • xsb:decode-from-url('%17') ergibt »%17«

Revision History
Revision 0.2.502012-05-27Stf

Status: beta

initiale Version

Parameter URL as="xs:string?"

zu konvertierende URL

11. Index

A C D E F H I J L M N P Q R S T U V

A

C

D

E

F

H

I

J

L

M

N

P

Q

R

S

T

U

V

12. Inconsistencies Detected!

12.1.  Top-level element problems

12.1.1. Top-level elements missing documentation

12.1.1.1. Module math.xsl

12.1.2. XSL construct problems

12.1.2.1. Module internals.testing.xsl
12.1.2.1.1. xsl:template problems
12.1.2.2. Module internals.xsl
12.1.2.2.1. xsl:function problems
  • Missing parameter type in <xsl:function name="xsb:is"> for <xsl:param name="input1">
  • Missing parameter type in <xsl:function name="xsb:is"> for <xsl:param name="input2">

12.1.3. Namespace qualified top-level elements and modes

  • mode="internals.self-test" not ignored and namespace prefix not in declared set of global and internal namespaces for top-level names and modes: <xsl:template>